代码拉取完成，页面将自动刷新
/*
* Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. 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 <tencentcloud/iss/v20230517/IssClient.h>
#include <tencentcloud/core/Executor.h>
#include <tencentcloud/core/Runnable.h>
using namespace TencentCloud;
using namespace TencentCloud::Iss::V20230517;
using namespace TencentCloud::Iss::V20230517::Model;
using namespace std;
namespace
{
const string VERSION = "2023-05-17";
const string ENDPOINT = "iss.tencentcloudapi.com";
}
IssClient::IssClient(const Credential &credential, const string ®ion) :
IssClient(credential, region, ClientProfile())
{
}
IssClient::IssClient(const Credential &credential, const string ®ion, const ClientProfile &profile) :
AbstractClient(ENDPOINT, VERSION, credential, region, profile)
{
}
IssClient::AddAITaskOutcome IssClient::AddAITask(const AddAITaskRequest &request)
{
auto outcome = MakeRequest(request, "AddAITask");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AddAITaskResponse rsp = AddAITaskResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AddAITaskOutcome(rsp);
else
return AddAITaskOutcome(o.GetError());
}
else
{
return AddAITaskOutcome(outcome.GetError());
}
}
void IssClient::AddAITaskAsync(const AddAITaskRequest& request, const AddAITaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AddAITask(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::AddAITaskOutcomeCallable IssClient::AddAITaskCallable(const AddAITaskRequest &request)
{
auto task = std::make_shared<std::packaged_task<AddAITaskOutcome()>>(
[this, request]()
{
return this->AddAITask(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::AddOrganizationOutcome IssClient::AddOrganization(const AddOrganizationRequest &request)
{
auto outcome = MakeRequest(request, "AddOrganization");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AddOrganizationResponse rsp = AddOrganizationResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AddOrganizationOutcome(rsp);
else
return AddOrganizationOutcome(o.GetError());
}
else
{
return AddOrganizationOutcome(outcome.GetError());
}
}
void IssClient::AddOrganizationAsync(const AddOrganizationRequest& request, const AddOrganizationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AddOrganization(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::AddOrganizationOutcomeCallable IssClient::AddOrganizationCallable(const AddOrganizationRequest &request)
{
auto task = std::make_shared<std::packaged_task<AddOrganizationOutcome()>>(
[this, request]()
{
return this->AddOrganization(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::AddRecordBackupPlanOutcome IssClient::AddRecordBackupPlan(const AddRecordBackupPlanRequest &request)
{
auto outcome = MakeRequest(request, "AddRecordBackupPlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AddRecordBackupPlanResponse rsp = AddRecordBackupPlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AddRecordBackupPlanOutcome(rsp);
else
return AddRecordBackupPlanOutcome(o.GetError());
}
else
{
return AddRecordBackupPlanOutcome(outcome.GetError());
}
}
void IssClient::AddRecordBackupPlanAsync(const AddRecordBackupPlanRequest& request, const AddRecordBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AddRecordBackupPlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::AddRecordBackupPlanOutcomeCallable IssClient::AddRecordBackupPlanCallable(const AddRecordBackupPlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<AddRecordBackupPlanOutcome()>>(
[this, request]()
{
return this->AddRecordBackupPlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::AddRecordBackupTemplateOutcome IssClient::AddRecordBackupTemplate(const AddRecordBackupTemplateRequest &request)
{
auto outcome = MakeRequest(request, "AddRecordBackupTemplate");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AddRecordBackupTemplateResponse rsp = AddRecordBackupTemplateResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AddRecordBackupTemplateOutcome(rsp);
else
return AddRecordBackupTemplateOutcome(o.GetError());
}
else
{
return AddRecordBackupTemplateOutcome(outcome.GetError());
}
}
void IssClient::AddRecordBackupTemplateAsync(const AddRecordBackupTemplateRequest& request, const AddRecordBackupTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AddRecordBackupTemplate(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::AddRecordBackupTemplateOutcomeCallable IssClient::AddRecordBackupTemplateCallable(const AddRecordBackupTemplateRequest &request)
{
auto task = std::make_shared<std::packaged_task<AddRecordBackupTemplateOutcome()>>(
[this, request]()
{
return this->AddRecordBackupTemplate(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::AddRecordPlanOutcome IssClient::AddRecordPlan(const AddRecordPlanRequest &request)
{
auto outcome = MakeRequest(request, "AddRecordPlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AddRecordPlanResponse rsp = AddRecordPlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AddRecordPlanOutcome(rsp);
else
return AddRecordPlanOutcome(o.GetError());
}
else
{
return AddRecordPlanOutcome(outcome.GetError());
}
}
void IssClient::AddRecordPlanAsync(const AddRecordPlanRequest& request, const AddRecordPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AddRecordPlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::AddRecordPlanOutcomeCallable IssClient::AddRecordPlanCallable(const AddRecordPlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<AddRecordPlanOutcome()>>(
[this, request]()
{
return this->AddRecordPlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::AddRecordRetrieveTaskOutcome IssClient::AddRecordRetrieveTask(const AddRecordRetrieveTaskRequest &request)
{
auto outcome = MakeRequest(request, "AddRecordRetrieveTask");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AddRecordRetrieveTaskResponse rsp = AddRecordRetrieveTaskResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AddRecordRetrieveTaskOutcome(rsp);
else
return AddRecordRetrieveTaskOutcome(o.GetError());
}
else
{
return AddRecordRetrieveTaskOutcome(outcome.GetError());
}
}
void IssClient::AddRecordRetrieveTaskAsync(const AddRecordRetrieveTaskRequest& request, const AddRecordRetrieveTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AddRecordRetrieveTask(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::AddRecordRetrieveTaskOutcomeCallable IssClient::AddRecordRetrieveTaskCallable(const AddRecordRetrieveTaskRequest &request)
{
auto task = std::make_shared<std::packaged_task<AddRecordRetrieveTaskOutcome()>>(
[this, request]()
{
return this->AddRecordRetrieveTask(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::AddRecordTemplateOutcome IssClient::AddRecordTemplate(const AddRecordTemplateRequest &request)
{
auto outcome = MakeRequest(request, "AddRecordTemplate");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AddRecordTemplateResponse rsp = AddRecordTemplateResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AddRecordTemplateOutcome(rsp);
else
return AddRecordTemplateOutcome(o.GetError());
}
else
{
return AddRecordTemplateOutcome(outcome.GetError());
}
}
void IssClient::AddRecordTemplateAsync(const AddRecordTemplateRequest& request, const AddRecordTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AddRecordTemplate(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::AddRecordTemplateOutcomeCallable IssClient::AddRecordTemplateCallable(const AddRecordTemplateRequest &request)
{
auto task = std::make_shared<std::packaged_task<AddRecordTemplateOutcome()>>(
[this, request]()
{
return this->AddRecordTemplate(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::AddStreamAuthOutcome IssClient::AddStreamAuth(const AddStreamAuthRequest &request)
{
auto outcome = MakeRequest(request, "AddStreamAuth");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AddStreamAuthResponse rsp = AddStreamAuthResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AddStreamAuthOutcome(rsp);
else
return AddStreamAuthOutcome(o.GetError());
}
else
{
return AddStreamAuthOutcome(outcome.GetError());
}
}
void IssClient::AddStreamAuthAsync(const AddStreamAuthRequest& request, const AddStreamAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AddStreamAuth(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::AddStreamAuthOutcomeCallable IssClient::AddStreamAuthCallable(const AddStreamAuthRequest &request)
{
auto task = std::make_shared<std::packaged_task<AddStreamAuthOutcome()>>(
[this, request]()
{
return this->AddStreamAuth(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::AddUserDeviceOutcome IssClient::AddUserDevice(const AddUserDeviceRequest &request)
{
auto outcome = MakeRequest(request, "AddUserDevice");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AddUserDeviceResponse rsp = AddUserDeviceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AddUserDeviceOutcome(rsp);
else
return AddUserDeviceOutcome(o.GetError());
}
else
{
return AddUserDeviceOutcome(outcome.GetError());
}
}
void IssClient::AddUserDeviceAsync(const AddUserDeviceRequest& request, const AddUserDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AddUserDevice(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::AddUserDeviceOutcomeCallable IssClient::AddUserDeviceCallable(const AddUserDeviceRequest &request)
{
auto task = std::make_shared<std::packaged_task<AddUserDeviceOutcome()>>(
[this, request]()
{
return this->AddUserDevice(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::BatchOperateDeviceOutcome IssClient::BatchOperateDevice(const BatchOperateDeviceRequest &request)
{
auto outcome = MakeRequest(request, "BatchOperateDevice");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
BatchOperateDeviceResponse rsp = BatchOperateDeviceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return BatchOperateDeviceOutcome(rsp);
else
return BatchOperateDeviceOutcome(o.GetError());
}
else
{
return BatchOperateDeviceOutcome(outcome.GetError());
}
}
void IssClient::BatchOperateDeviceAsync(const BatchOperateDeviceRequest& request, const BatchOperateDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->BatchOperateDevice(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::BatchOperateDeviceOutcomeCallable IssClient::BatchOperateDeviceCallable(const BatchOperateDeviceRequest &request)
{
auto task = std::make_shared<std::packaged_task<BatchOperateDeviceOutcome()>>(
[this, request]()
{
return this->BatchOperateDevice(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::CheckDomainOutcome IssClient::CheckDomain(const CheckDomainRequest &request)
{
auto outcome = MakeRequest(request, "CheckDomain");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CheckDomainResponse rsp = CheckDomainResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CheckDomainOutcome(rsp);
else
return CheckDomainOutcome(o.GetError());
}
else
{
return CheckDomainOutcome(outcome.GetError());
}
}
void IssClient::CheckDomainAsync(const CheckDomainRequest& request, const CheckDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CheckDomain(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::CheckDomainOutcomeCallable IssClient::CheckDomainCallable(const CheckDomainRequest &request)
{
auto task = std::make_shared<std::packaged_task<CheckDomainOutcome()>>(
[this, request]()
{
return this->CheckDomain(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ControlDevicePTZOutcome IssClient::ControlDevicePTZ(const ControlDevicePTZRequest &request)
{
auto outcome = MakeRequest(request, "ControlDevicePTZ");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ControlDevicePTZResponse rsp = ControlDevicePTZResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ControlDevicePTZOutcome(rsp);
else
return ControlDevicePTZOutcome(o.GetError());
}
else
{
return ControlDevicePTZOutcome(outcome.GetError());
}
}
void IssClient::ControlDevicePTZAsync(const ControlDevicePTZRequest& request, const ControlDevicePTZAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ControlDevicePTZ(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ControlDevicePTZOutcomeCallable IssClient::ControlDevicePTZCallable(const ControlDevicePTZRequest &request)
{
auto task = std::make_shared<std::packaged_task<ControlDevicePTZOutcome()>>(
[this, request]()
{
return this->ControlDevicePTZ(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ControlDevicePresetOutcome IssClient::ControlDevicePreset(const ControlDevicePresetRequest &request)
{
auto outcome = MakeRequest(request, "ControlDevicePreset");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ControlDevicePresetResponse rsp = ControlDevicePresetResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ControlDevicePresetOutcome(rsp);
else
return ControlDevicePresetOutcome(o.GetError());
}
else
{
return ControlDevicePresetOutcome(outcome.GetError());
}
}
void IssClient::ControlDevicePresetAsync(const ControlDevicePresetRequest& request, const ControlDevicePresetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ControlDevicePreset(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ControlDevicePresetOutcomeCallable IssClient::ControlDevicePresetCallable(const ControlDevicePresetRequest &request)
{
auto task = std::make_shared<std::packaged_task<ControlDevicePresetOutcome()>>(
[this, request]()
{
return this->ControlDevicePreset(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ControlDeviceStreamOutcome IssClient::ControlDeviceStream(const ControlDeviceStreamRequest &request)
{
auto outcome = MakeRequest(request, "ControlDeviceStream");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ControlDeviceStreamResponse rsp = ControlDeviceStreamResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ControlDeviceStreamOutcome(rsp);
else
return ControlDeviceStreamOutcome(o.GetError());
}
else
{
return ControlDeviceStreamOutcome(outcome.GetError());
}
}
void IssClient::ControlDeviceStreamAsync(const ControlDeviceStreamRequest& request, const ControlDeviceStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ControlDeviceStream(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ControlDeviceStreamOutcomeCallable IssClient::ControlDeviceStreamCallable(const ControlDeviceStreamRequest &request)
{
auto task = std::make_shared<std::packaged_task<ControlDeviceStreamOutcome()>>(
[this, request]()
{
return this->ControlDeviceStream(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ControlRecordOutcome IssClient::ControlRecord(const ControlRecordRequest &request)
{
auto outcome = MakeRequest(request, "ControlRecord");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ControlRecordResponse rsp = ControlRecordResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ControlRecordOutcome(rsp);
else
return ControlRecordOutcome(o.GetError());
}
else
{
return ControlRecordOutcome(outcome.GetError());
}
}
void IssClient::ControlRecordAsync(const ControlRecordRequest& request, const ControlRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ControlRecord(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ControlRecordOutcomeCallable IssClient::ControlRecordCallable(const ControlRecordRequest &request)
{
auto task = std::make_shared<std::packaged_task<ControlRecordOutcome()>>(
[this, request]()
{
return this->ControlRecord(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ControlRecordTimelineOutcome IssClient::ControlRecordTimeline(const ControlRecordTimelineRequest &request)
{
auto outcome = MakeRequest(request, "ControlRecordTimeline");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ControlRecordTimelineResponse rsp = ControlRecordTimelineResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ControlRecordTimelineOutcome(rsp);
else
return ControlRecordTimelineOutcome(o.GetError());
}
else
{
return ControlRecordTimelineOutcome(outcome.GetError());
}
}
void IssClient::ControlRecordTimelineAsync(const ControlRecordTimelineRequest& request, const ControlRecordTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ControlRecordTimeline(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ControlRecordTimelineOutcomeCallable IssClient::ControlRecordTimelineCallable(const ControlRecordTimelineRequest &request)
{
auto task = std::make_shared<std::packaged_task<ControlRecordTimelineOutcome()>>(
[this, request]()
{
return this->ControlRecordTimeline(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteAITaskOutcome IssClient::DeleteAITask(const DeleteAITaskRequest &request)
{
auto outcome = MakeRequest(request, "DeleteAITask");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteAITaskResponse rsp = DeleteAITaskResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteAITaskOutcome(rsp);
else
return DeleteAITaskOutcome(o.GetError());
}
else
{
return DeleteAITaskOutcome(outcome.GetError());
}
}
void IssClient::DeleteAITaskAsync(const DeleteAITaskRequest& request, const DeleteAITaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteAITask(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteAITaskOutcomeCallable IssClient::DeleteAITaskCallable(const DeleteAITaskRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteAITaskOutcome()>>(
[this, request]()
{
return this->DeleteAITask(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteDomainOutcome IssClient::DeleteDomain(const DeleteDomainRequest &request)
{
auto outcome = MakeRequest(request, "DeleteDomain");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteDomainResponse rsp = DeleteDomainResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteDomainOutcome(rsp);
else
return DeleteDomainOutcome(o.GetError());
}
else
{
return DeleteDomainOutcome(outcome.GetError());
}
}
void IssClient::DeleteDomainAsync(const DeleteDomainRequest& request, const DeleteDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteDomain(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteDomainOutcomeCallable IssClient::DeleteDomainCallable(const DeleteDomainRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteDomainOutcome()>>(
[this, request]()
{
return this->DeleteDomain(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteGatewayOutcome IssClient::DeleteGateway(const DeleteGatewayRequest &request)
{
auto outcome = MakeRequest(request, "DeleteGateway");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteGatewayResponse rsp = DeleteGatewayResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteGatewayOutcome(rsp);
else
return DeleteGatewayOutcome(o.GetError());
}
else
{
return DeleteGatewayOutcome(outcome.GetError());
}
}
void IssClient::DeleteGatewayAsync(const DeleteGatewayRequest& request, const DeleteGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteGateway(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteGatewayOutcomeCallable IssClient::DeleteGatewayCallable(const DeleteGatewayRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteGatewayOutcome()>>(
[this, request]()
{
return this->DeleteGateway(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteOrganizationOutcome IssClient::DeleteOrganization(const DeleteOrganizationRequest &request)
{
auto outcome = MakeRequest(request, "DeleteOrganization");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteOrganizationResponse rsp = DeleteOrganizationResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteOrganizationOutcome(rsp);
else
return DeleteOrganizationOutcome(o.GetError());
}
else
{
return DeleteOrganizationOutcome(outcome.GetError());
}
}
void IssClient::DeleteOrganizationAsync(const DeleteOrganizationRequest& request, const DeleteOrganizationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteOrganization(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteOrganizationOutcomeCallable IssClient::DeleteOrganizationCallable(const DeleteOrganizationRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteOrganizationOutcome()>>(
[this, request]()
{
return this->DeleteOrganization(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteRecordBackupPlanOutcome IssClient::DeleteRecordBackupPlan(const DeleteRecordBackupPlanRequest &request)
{
auto outcome = MakeRequest(request, "DeleteRecordBackupPlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteRecordBackupPlanResponse rsp = DeleteRecordBackupPlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteRecordBackupPlanOutcome(rsp);
else
return DeleteRecordBackupPlanOutcome(o.GetError());
}
else
{
return DeleteRecordBackupPlanOutcome(outcome.GetError());
}
}
void IssClient::DeleteRecordBackupPlanAsync(const DeleteRecordBackupPlanRequest& request, const DeleteRecordBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteRecordBackupPlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteRecordBackupPlanOutcomeCallable IssClient::DeleteRecordBackupPlanCallable(const DeleteRecordBackupPlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteRecordBackupPlanOutcome()>>(
[this, request]()
{
return this->DeleteRecordBackupPlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteRecordBackupTemplateOutcome IssClient::DeleteRecordBackupTemplate(const DeleteRecordBackupTemplateRequest &request)
{
auto outcome = MakeRequest(request, "DeleteRecordBackupTemplate");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteRecordBackupTemplateResponse rsp = DeleteRecordBackupTemplateResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteRecordBackupTemplateOutcome(rsp);
else
return DeleteRecordBackupTemplateOutcome(o.GetError());
}
else
{
return DeleteRecordBackupTemplateOutcome(outcome.GetError());
}
}
void IssClient::DeleteRecordBackupTemplateAsync(const DeleteRecordBackupTemplateRequest& request, const DeleteRecordBackupTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteRecordBackupTemplate(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteRecordBackupTemplateOutcomeCallable IssClient::DeleteRecordBackupTemplateCallable(const DeleteRecordBackupTemplateRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteRecordBackupTemplateOutcome()>>(
[this, request]()
{
return this->DeleteRecordBackupTemplate(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteRecordPlanOutcome IssClient::DeleteRecordPlan(const DeleteRecordPlanRequest &request)
{
auto outcome = MakeRequest(request, "DeleteRecordPlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteRecordPlanResponse rsp = DeleteRecordPlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteRecordPlanOutcome(rsp);
else
return DeleteRecordPlanOutcome(o.GetError());
}
else
{
return DeleteRecordPlanOutcome(outcome.GetError());
}
}
void IssClient::DeleteRecordPlanAsync(const DeleteRecordPlanRequest& request, const DeleteRecordPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteRecordPlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteRecordPlanOutcomeCallable IssClient::DeleteRecordPlanCallable(const DeleteRecordPlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteRecordPlanOutcome()>>(
[this, request]()
{
return this->DeleteRecordPlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteRecordRetrieveTaskOutcome IssClient::DeleteRecordRetrieveTask(const DeleteRecordRetrieveTaskRequest &request)
{
auto outcome = MakeRequest(request, "DeleteRecordRetrieveTask");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteRecordRetrieveTaskResponse rsp = DeleteRecordRetrieveTaskResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteRecordRetrieveTaskOutcome(rsp);
else
return DeleteRecordRetrieveTaskOutcome(o.GetError());
}
else
{
return DeleteRecordRetrieveTaskOutcome(outcome.GetError());
}
}
void IssClient::DeleteRecordRetrieveTaskAsync(const DeleteRecordRetrieveTaskRequest& request, const DeleteRecordRetrieveTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteRecordRetrieveTask(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteRecordRetrieveTaskOutcomeCallable IssClient::DeleteRecordRetrieveTaskCallable(const DeleteRecordRetrieveTaskRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteRecordRetrieveTaskOutcome()>>(
[this, request]()
{
return this->DeleteRecordRetrieveTask(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteRecordTemplateOutcome IssClient::DeleteRecordTemplate(const DeleteRecordTemplateRequest &request)
{
auto outcome = MakeRequest(request, "DeleteRecordTemplate");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteRecordTemplateResponse rsp = DeleteRecordTemplateResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteRecordTemplateOutcome(rsp);
else
return DeleteRecordTemplateOutcome(o.GetError());
}
else
{
return DeleteRecordTemplateOutcome(outcome.GetError());
}
}
void IssClient::DeleteRecordTemplateAsync(const DeleteRecordTemplateRequest& request, const DeleteRecordTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteRecordTemplate(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteRecordTemplateOutcomeCallable IssClient::DeleteRecordTemplateCallable(const DeleteRecordTemplateRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteRecordTemplateOutcome()>>(
[this, request]()
{
return this->DeleteRecordTemplate(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DeleteUserDeviceOutcome IssClient::DeleteUserDevice(const DeleteUserDeviceRequest &request)
{
auto outcome = MakeRequest(request, "DeleteUserDevice");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteUserDeviceResponse rsp = DeleteUserDeviceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteUserDeviceOutcome(rsp);
else
return DeleteUserDeviceOutcome(o.GetError());
}
else
{
return DeleteUserDeviceOutcome(outcome.GetError());
}
}
void IssClient::DeleteUserDeviceAsync(const DeleteUserDeviceRequest& request, const DeleteUserDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteUserDevice(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DeleteUserDeviceOutcomeCallable IssClient::DeleteUserDeviceCallable(const DeleteUserDeviceRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteUserDeviceOutcome()>>(
[this, request]()
{
return this->DeleteUserDevice(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeAITaskOutcome IssClient::DescribeAITask(const DescribeAITaskRequest &request)
{
auto outcome = MakeRequest(request, "DescribeAITask");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeAITaskResponse rsp = DescribeAITaskResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeAITaskOutcome(rsp);
else
return DescribeAITaskOutcome(o.GetError());
}
else
{
return DescribeAITaskOutcome(outcome.GetError());
}
}
void IssClient::DescribeAITaskAsync(const DescribeAITaskRequest& request, const DescribeAITaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeAITask(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeAITaskOutcomeCallable IssClient::DescribeAITaskCallable(const DescribeAITaskRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeAITaskOutcome()>>(
[this, request]()
{
return this->DescribeAITask(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeAITaskResultOutcome IssClient::DescribeAITaskResult(const DescribeAITaskResultRequest &request)
{
auto outcome = MakeRequest(request, "DescribeAITaskResult");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeAITaskResultResponse rsp = DescribeAITaskResultResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeAITaskResultOutcome(rsp);
else
return DescribeAITaskResultOutcome(o.GetError());
}
else
{
return DescribeAITaskResultOutcome(outcome.GetError());
}
}
void IssClient::DescribeAITaskResultAsync(const DescribeAITaskResultRequest& request, const DescribeAITaskResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeAITaskResult(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeAITaskResultOutcomeCallable IssClient::DescribeAITaskResultCallable(const DescribeAITaskResultRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeAITaskResultOutcome()>>(
[this, request]()
{
return this->DescribeAITaskResult(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeCNAMEOutcome IssClient::DescribeCNAME(const DescribeCNAMERequest &request)
{
auto outcome = MakeRequest(request, "DescribeCNAME");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeCNAMEResponse rsp = DescribeCNAMEResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeCNAMEOutcome(rsp);
else
return DescribeCNAMEOutcome(o.GetError());
}
else
{
return DescribeCNAMEOutcome(outcome.GetError());
}
}
void IssClient::DescribeCNAMEAsync(const DescribeCNAMERequest& request, const DescribeCNAMEAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeCNAME(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeCNAMEOutcomeCallable IssClient::DescribeCNAMECallable(const DescribeCNAMERequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeCNAMEOutcome()>>(
[this, request]()
{
return this->DescribeCNAME(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeDeviceChannelOutcome IssClient::DescribeDeviceChannel(const DescribeDeviceChannelRequest &request)
{
auto outcome = MakeRequest(request, "DescribeDeviceChannel");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeDeviceChannelResponse rsp = DescribeDeviceChannelResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeDeviceChannelOutcome(rsp);
else
return DescribeDeviceChannelOutcome(o.GetError());
}
else
{
return DescribeDeviceChannelOutcome(outcome.GetError());
}
}
void IssClient::DescribeDeviceChannelAsync(const DescribeDeviceChannelRequest& request, const DescribeDeviceChannelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeDeviceChannel(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeDeviceChannelOutcomeCallable IssClient::DescribeDeviceChannelCallable(const DescribeDeviceChannelRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeDeviceChannelOutcome()>>(
[this, request]()
{
return this->DescribeDeviceChannel(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeDevicePresetOutcome IssClient::DescribeDevicePreset(const DescribeDevicePresetRequest &request)
{
auto outcome = MakeRequest(request, "DescribeDevicePreset");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeDevicePresetResponse rsp = DescribeDevicePresetResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeDevicePresetOutcome(rsp);
else
return DescribeDevicePresetOutcome(o.GetError());
}
else
{
return DescribeDevicePresetOutcome(outcome.GetError());
}
}
void IssClient::DescribeDevicePresetAsync(const DescribeDevicePresetRequest& request, const DescribeDevicePresetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeDevicePreset(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeDevicePresetOutcomeCallable IssClient::DescribeDevicePresetCallable(const DescribeDevicePresetRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeDevicePresetOutcome()>>(
[this, request]()
{
return this->DescribeDevicePreset(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeDeviceRegionOutcome IssClient::DescribeDeviceRegion(const DescribeDeviceRegionRequest &request)
{
auto outcome = MakeRequest(request, "DescribeDeviceRegion");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeDeviceRegionResponse rsp = DescribeDeviceRegionResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeDeviceRegionOutcome(rsp);
else
return DescribeDeviceRegionOutcome(o.GetError());
}
else
{
return DescribeDeviceRegionOutcome(outcome.GetError());
}
}
void IssClient::DescribeDeviceRegionAsync(const DescribeDeviceRegionRequest& request, const DescribeDeviceRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeDeviceRegion(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeDeviceRegionOutcomeCallable IssClient::DescribeDeviceRegionCallable(const DescribeDeviceRegionRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeDeviceRegionOutcome()>>(
[this, request]()
{
return this->DescribeDeviceRegion(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeDomainOutcome IssClient::DescribeDomain(const DescribeDomainRequest &request)
{
auto outcome = MakeRequest(request, "DescribeDomain");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeDomainResponse rsp = DescribeDomainResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeDomainOutcome(rsp);
else
return DescribeDomainOutcome(o.GetError());
}
else
{
return DescribeDomainOutcome(outcome.GetError());
}
}
void IssClient::DescribeDomainAsync(const DescribeDomainRequest& request, const DescribeDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeDomain(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeDomainOutcomeCallable IssClient::DescribeDomainCallable(const DescribeDomainRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeDomainOutcome()>>(
[this, request]()
{
return this->DescribeDomain(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeDomainRegionOutcome IssClient::DescribeDomainRegion(const DescribeDomainRegionRequest &request)
{
auto outcome = MakeRequest(request, "DescribeDomainRegion");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeDomainRegionResponse rsp = DescribeDomainRegionResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeDomainRegionOutcome(rsp);
else
return DescribeDomainRegionOutcome(o.GetError());
}
else
{
return DescribeDomainRegionOutcome(outcome.GetError());
}
}
void IssClient::DescribeDomainRegionAsync(const DescribeDomainRegionRequest& request, const DescribeDomainRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeDomainRegion(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeDomainRegionOutcomeCallable IssClient::DescribeDomainRegionCallable(const DescribeDomainRegionRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeDomainRegionOutcome()>>(
[this, request]()
{
return this->DescribeDomainRegion(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeGatewayOutcome IssClient::DescribeGateway(const DescribeGatewayRequest &request)
{
auto outcome = MakeRequest(request, "DescribeGateway");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeGatewayResponse rsp = DescribeGatewayResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeGatewayOutcome(rsp);
else
return DescribeGatewayOutcome(o.GetError());
}
else
{
return DescribeGatewayOutcome(outcome.GetError());
}
}
void IssClient::DescribeGatewayAsync(const DescribeGatewayRequest& request, const DescribeGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeGateway(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeGatewayOutcomeCallable IssClient::DescribeGatewayCallable(const DescribeGatewayRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeGatewayOutcome()>>(
[this, request]()
{
return this->DescribeGateway(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeGatewayMonitorOutcome IssClient::DescribeGatewayMonitor(const DescribeGatewayMonitorRequest &request)
{
auto outcome = MakeRequest(request, "DescribeGatewayMonitor");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeGatewayMonitorResponse rsp = DescribeGatewayMonitorResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeGatewayMonitorOutcome(rsp);
else
return DescribeGatewayMonitorOutcome(o.GetError());
}
else
{
return DescribeGatewayMonitorOutcome(outcome.GetError());
}
}
void IssClient::DescribeGatewayMonitorAsync(const DescribeGatewayMonitorRequest& request, const DescribeGatewayMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeGatewayMonitor(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeGatewayMonitorOutcomeCallable IssClient::DescribeGatewayMonitorCallable(const DescribeGatewayMonitorRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeGatewayMonitorOutcome()>>(
[this, request]()
{
return this->DescribeGatewayMonitor(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeGatewayProtocolOutcome IssClient::DescribeGatewayProtocol(const DescribeGatewayProtocolRequest &request)
{
auto outcome = MakeRequest(request, "DescribeGatewayProtocol");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeGatewayProtocolResponse rsp = DescribeGatewayProtocolResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeGatewayProtocolOutcome(rsp);
else
return DescribeGatewayProtocolOutcome(o.GetError());
}
else
{
return DescribeGatewayProtocolOutcome(outcome.GetError());
}
}
void IssClient::DescribeGatewayProtocolAsync(const DescribeGatewayProtocolRequest& request, const DescribeGatewayProtocolAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeGatewayProtocol(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeGatewayProtocolOutcomeCallable IssClient::DescribeGatewayProtocolCallable(const DescribeGatewayProtocolRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeGatewayProtocolOutcome()>>(
[this, request]()
{
return this->DescribeGatewayProtocol(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeGatewayVersionOutcome IssClient::DescribeGatewayVersion(const DescribeGatewayVersionRequest &request)
{
auto outcome = MakeRequest(request, "DescribeGatewayVersion");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeGatewayVersionResponse rsp = DescribeGatewayVersionResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeGatewayVersionOutcome(rsp);
else
return DescribeGatewayVersionOutcome(o.GetError());
}
else
{
return DescribeGatewayVersionOutcome(outcome.GetError());
}
}
void IssClient::DescribeGatewayVersionAsync(const DescribeGatewayVersionRequest& request, const DescribeGatewayVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeGatewayVersion(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeGatewayVersionOutcomeCallable IssClient::DescribeGatewayVersionCallable(const DescribeGatewayVersionRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeGatewayVersionOutcome()>>(
[this, request]()
{
return this->DescribeGatewayVersion(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeOrganizationOutcome IssClient::DescribeOrganization(const DescribeOrganizationRequest &request)
{
auto outcome = MakeRequest(request, "DescribeOrganization");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeOrganizationResponse rsp = DescribeOrganizationResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeOrganizationOutcome(rsp);
else
return DescribeOrganizationOutcome(o.GetError());
}
else
{
return DescribeOrganizationOutcome(outcome.GetError());
}
}
void IssClient::DescribeOrganizationAsync(const DescribeOrganizationRequest& request, const DescribeOrganizationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeOrganization(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeOrganizationOutcomeCallable IssClient::DescribeOrganizationCallable(const DescribeOrganizationRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeOrganizationOutcome()>>(
[this, request]()
{
return this->DescribeOrganization(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeRecordBackupPlanOutcome IssClient::DescribeRecordBackupPlan(const DescribeRecordBackupPlanRequest &request)
{
auto outcome = MakeRequest(request, "DescribeRecordBackupPlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeRecordBackupPlanResponse rsp = DescribeRecordBackupPlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeRecordBackupPlanOutcome(rsp);
else
return DescribeRecordBackupPlanOutcome(o.GetError());
}
else
{
return DescribeRecordBackupPlanOutcome(outcome.GetError());
}
}
void IssClient::DescribeRecordBackupPlanAsync(const DescribeRecordBackupPlanRequest& request, const DescribeRecordBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeRecordBackupPlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeRecordBackupPlanOutcomeCallable IssClient::DescribeRecordBackupPlanCallable(const DescribeRecordBackupPlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeRecordBackupPlanOutcome()>>(
[this, request]()
{
return this->DescribeRecordBackupPlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeRecordBackupTemplateOutcome IssClient::DescribeRecordBackupTemplate(const DescribeRecordBackupTemplateRequest &request)
{
auto outcome = MakeRequest(request, "DescribeRecordBackupTemplate");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeRecordBackupTemplateResponse rsp = DescribeRecordBackupTemplateResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeRecordBackupTemplateOutcome(rsp);
else
return DescribeRecordBackupTemplateOutcome(o.GetError());
}
else
{
return DescribeRecordBackupTemplateOutcome(outcome.GetError());
}
}
void IssClient::DescribeRecordBackupTemplateAsync(const DescribeRecordBackupTemplateRequest& request, const DescribeRecordBackupTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeRecordBackupTemplate(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeRecordBackupTemplateOutcomeCallable IssClient::DescribeRecordBackupTemplateCallable(const DescribeRecordBackupTemplateRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeRecordBackupTemplateOutcome()>>(
[this, request]()
{
return this->DescribeRecordBackupTemplate(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeRecordFileOutcome IssClient::DescribeRecordFile(const DescribeRecordFileRequest &request)
{
auto outcome = MakeRequest(request, "DescribeRecordFile");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeRecordFileResponse rsp = DescribeRecordFileResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeRecordFileOutcome(rsp);
else
return DescribeRecordFileOutcome(o.GetError());
}
else
{
return DescribeRecordFileOutcome(outcome.GetError());
}
}
void IssClient::DescribeRecordFileAsync(const DescribeRecordFileRequest& request, const DescribeRecordFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeRecordFile(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeRecordFileOutcomeCallable IssClient::DescribeRecordFileCallable(const DescribeRecordFileRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeRecordFileOutcome()>>(
[this, request]()
{
return this->DescribeRecordFile(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeRecordPlanOutcome IssClient::DescribeRecordPlan(const DescribeRecordPlanRequest &request)
{
auto outcome = MakeRequest(request, "DescribeRecordPlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeRecordPlanResponse rsp = DescribeRecordPlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeRecordPlanOutcome(rsp);
else
return DescribeRecordPlanOutcome(o.GetError());
}
else
{
return DescribeRecordPlanOutcome(outcome.GetError());
}
}
void IssClient::DescribeRecordPlanAsync(const DescribeRecordPlanRequest& request, const DescribeRecordPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeRecordPlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeRecordPlanOutcomeCallable IssClient::DescribeRecordPlanCallable(const DescribeRecordPlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeRecordPlanOutcome()>>(
[this, request]()
{
return this->DescribeRecordPlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeRecordPlaybackUrlOutcome IssClient::DescribeRecordPlaybackUrl(const DescribeRecordPlaybackUrlRequest &request)
{
auto outcome = MakeRequest(request, "DescribeRecordPlaybackUrl");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeRecordPlaybackUrlResponse rsp = DescribeRecordPlaybackUrlResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeRecordPlaybackUrlOutcome(rsp);
else
return DescribeRecordPlaybackUrlOutcome(o.GetError());
}
else
{
return DescribeRecordPlaybackUrlOutcome(outcome.GetError());
}
}
void IssClient::DescribeRecordPlaybackUrlAsync(const DescribeRecordPlaybackUrlRequest& request, const DescribeRecordPlaybackUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeRecordPlaybackUrl(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeRecordPlaybackUrlOutcomeCallable IssClient::DescribeRecordPlaybackUrlCallable(const DescribeRecordPlaybackUrlRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeRecordPlaybackUrlOutcome()>>(
[this, request]()
{
return this->DescribeRecordPlaybackUrl(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeRecordRetrieveTaskOutcome IssClient::DescribeRecordRetrieveTask(const DescribeRecordRetrieveTaskRequest &request)
{
auto outcome = MakeRequest(request, "DescribeRecordRetrieveTask");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeRecordRetrieveTaskResponse rsp = DescribeRecordRetrieveTaskResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeRecordRetrieveTaskOutcome(rsp);
else
return DescribeRecordRetrieveTaskOutcome(o.GetError());
}
else
{
return DescribeRecordRetrieveTaskOutcome(outcome.GetError());
}
}
void IssClient::DescribeRecordRetrieveTaskAsync(const DescribeRecordRetrieveTaskRequest& request, const DescribeRecordRetrieveTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeRecordRetrieveTask(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeRecordRetrieveTaskOutcomeCallable IssClient::DescribeRecordRetrieveTaskCallable(const DescribeRecordRetrieveTaskRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeRecordRetrieveTaskOutcome()>>(
[this, request]()
{
return this->DescribeRecordRetrieveTask(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeRecordSliceOutcome IssClient::DescribeRecordSlice(const DescribeRecordSliceRequest &request)
{
auto outcome = MakeRequest(request, "DescribeRecordSlice");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeRecordSliceResponse rsp = DescribeRecordSliceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeRecordSliceOutcome(rsp);
else
return DescribeRecordSliceOutcome(o.GetError());
}
else
{
return DescribeRecordSliceOutcome(outcome.GetError());
}
}
void IssClient::DescribeRecordSliceAsync(const DescribeRecordSliceRequest& request, const DescribeRecordSliceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeRecordSlice(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeRecordSliceOutcomeCallable IssClient::DescribeRecordSliceCallable(const DescribeRecordSliceRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeRecordSliceOutcome()>>(
[this, request]()
{
return this->DescribeRecordSlice(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeRecordTemplateOutcome IssClient::DescribeRecordTemplate(const DescribeRecordTemplateRequest &request)
{
auto outcome = MakeRequest(request, "DescribeRecordTemplate");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeRecordTemplateResponse rsp = DescribeRecordTemplateResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeRecordTemplateOutcome(rsp);
else
return DescribeRecordTemplateOutcome(o.GetError());
}
else
{
return DescribeRecordTemplateOutcome(outcome.GetError());
}
}
void IssClient::DescribeRecordTemplateAsync(const DescribeRecordTemplateRequest& request, const DescribeRecordTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeRecordTemplate(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeRecordTemplateOutcomeCallable IssClient::DescribeRecordTemplateCallable(const DescribeRecordTemplateRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeRecordTemplateOutcome()>>(
[this, request]()
{
return this->DescribeRecordTemplate(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeStreamAuthOutcome IssClient::DescribeStreamAuth(const DescribeStreamAuthRequest &request)
{
auto outcome = MakeRequest(request, "DescribeStreamAuth");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeStreamAuthResponse rsp = DescribeStreamAuthResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeStreamAuthOutcome(rsp);
else
return DescribeStreamAuthOutcome(o.GetError());
}
else
{
return DescribeStreamAuthOutcome(outcome.GetError());
}
}
void IssClient::DescribeStreamAuthAsync(const DescribeStreamAuthRequest& request, const DescribeStreamAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeStreamAuth(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeStreamAuthOutcomeCallable IssClient::DescribeStreamAuthCallable(const DescribeStreamAuthRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeStreamAuthOutcome()>>(
[this, request]()
{
return this->DescribeStreamAuth(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeTaskOutcome IssClient::DescribeTask(const DescribeTaskRequest &request)
{
auto outcome = MakeRequest(request, "DescribeTask");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeTaskResponse rsp = DescribeTaskResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeTaskOutcome(rsp);
else
return DescribeTaskOutcome(o.GetError());
}
else
{
return DescribeTaskOutcome(outcome.GetError());
}
}
void IssClient::DescribeTaskAsync(const DescribeTaskRequest& request, const DescribeTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeTask(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeTaskOutcomeCallable IssClient::DescribeTaskCallable(const DescribeTaskRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeTaskOutcome()>>(
[this, request]()
{
return this->DescribeTask(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeUserDeviceOutcome IssClient::DescribeUserDevice(const DescribeUserDeviceRequest &request)
{
auto outcome = MakeRequest(request, "DescribeUserDevice");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeUserDeviceResponse rsp = DescribeUserDeviceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeUserDeviceOutcome(rsp);
else
return DescribeUserDeviceOutcome(o.GetError());
}
else
{
return DescribeUserDeviceOutcome(outcome.GetError());
}
}
void IssClient::DescribeUserDeviceAsync(const DescribeUserDeviceRequest& request, const DescribeUserDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeUserDevice(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeUserDeviceOutcomeCallable IssClient::DescribeUserDeviceCallable(const DescribeUserDeviceRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeUserDeviceOutcome()>>(
[this, request]()
{
return this->DescribeUserDevice(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeVideoBitRateOutcome IssClient::DescribeVideoBitRate(const DescribeVideoBitRateRequest &request)
{
auto outcome = MakeRequest(request, "DescribeVideoBitRate");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeVideoBitRateResponse rsp = DescribeVideoBitRateResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeVideoBitRateOutcome(rsp);
else
return DescribeVideoBitRateOutcome(o.GetError());
}
else
{
return DescribeVideoBitRateOutcome(outcome.GetError());
}
}
void IssClient::DescribeVideoBitRateAsync(const DescribeVideoBitRateRequest& request, const DescribeVideoBitRateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeVideoBitRate(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeVideoBitRateOutcomeCallable IssClient::DescribeVideoBitRateCallable(const DescribeVideoBitRateRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeVideoBitRateOutcome()>>(
[this, request]()
{
return this->DescribeVideoBitRate(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::DescribeVideoDownloadUrlOutcome IssClient::DescribeVideoDownloadUrl(const DescribeVideoDownloadUrlRequest &request)
{
auto outcome = MakeRequest(request, "DescribeVideoDownloadUrl");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeVideoDownloadUrlResponse rsp = DescribeVideoDownloadUrlResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeVideoDownloadUrlOutcome(rsp);
else
return DescribeVideoDownloadUrlOutcome(o.GetError());
}
else
{
return DescribeVideoDownloadUrlOutcome(outcome.GetError());
}
}
void IssClient::DescribeVideoDownloadUrlAsync(const DescribeVideoDownloadUrlRequest& request, const DescribeVideoDownloadUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeVideoDownloadUrl(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::DescribeVideoDownloadUrlOutcomeCallable IssClient::DescribeVideoDownloadUrlCallable(const DescribeVideoDownloadUrlRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeVideoDownloadUrlOutcome()>>(
[this, request]()
{
return this->DescribeVideoDownloadUrl(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListAITasksOutcome IssClient::ListAITasks(const ListAITasksRequest &request)
{
auto outcome = MakeRequest(request, "ListAITasks");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListAITasksResponse rsp = ListAITasksResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListAITasksOutcome(rsp);
else
return ListAITasksOutcome(o.GetError());
}
else
{
return ListAITasksOutcome(outcome.GetError());
}
}
void IssClient::ListAITasksAsync(const ListAITasksRequest& request, const ListAITasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListAITasks(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListAITasksOutcomeCallable IssClient::ListAITasksCallable(const ListAITasksRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListAITasksOutcome()>>(
[this, request]()
{
return this->ListAITasks(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListDevicesOutcome IssClient::ListDevices(const ListDevicesRequest &request)
{
auto outcome = MakeRequest(request, "ListDevices");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListDevicesResponse rsp = ListDevicesResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListDevicesOutcome(rsp);
else
return ListDevicesOutcome(o.GetError());
}
else
{
return ListDevicesOutcome(outcome.GetError());
}
}
void IssClient::ListDevicesAsync(const ListDevicesRequest& request, const ListDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListDevices(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListDevicesOutcomeCallable IssClient::ListDevicesCallable(const ListDevicesRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListDevicesOutcome()>>(
[this, request]()
{
return this->ListDevices(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListGatewayDevicesOutcome IssClient::ListGatewayDevices(const ListGatewayDevicesRequest &request)
{
auto outcome = MakeRequest(request, "ListGatewayDevices");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListGatewayDevicesResponse rsp = ListGatewayDevicesResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListGatewayDevicesOutcome(rsp);
else
return ListGatewayDevicesOutcome(o.GetError());
}
else
{
return ListGatewayDevicesOutcome(outcome.GetError());
}
}
void IssClient::ListGatewayDevicesAsync(const ListGatewayDevicesRequest& request, const ListGatewayDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListGatewayDevices(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListGatewayDevicesOutcomeCallable IssClient::ListGatewayDevicesCallable(const ListGatewayDevicesRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListGatewayDevicesOutcome()>>(
[this, request]()
{
return this->ListGatewayDevices(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListGatewaysOutcome IssClient::ListGateways(const ListGatewaysRequest &request)
{
auto outcome = MakeRequest(request, "ListGateways");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListGatewaysResponse rsp = ListGatewaysResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListGatewaysOutcome(rsp);
else
return ListGatewaysOutcome(o.GetError());
}
else
{
return ListGatewaysOutcome(outcome.GetError());
}
}
void IssClient::ListGatewaysAsync(const ListGatewaysRequest& request, const ListGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListGateways(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListGatewaysOutcomeCallable IssClient::ListGatewaysCallable(const ListGatewaysRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListGatewaysOutcome()>>(
[this, request]()
{
return this->ListGateways(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListOrganizationChannelNumbersOutcome IssClient::ListOrganizationChannelNumbers(const ListOrganizationChannelNumbersRequest &request)
{
auto outcome = MakeRequest(request, "ListOrganizationChannelNumbers");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListOrganizationChannelNumbersResponse rsp = ListOrganizationChannelNumbersResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListOrganizationChannelNumbersOutcome(rsp);
else
return ListOrganizationChannelNumbersOutcome(o.GetError());
}
else
{
return ListOrganizationChannelNumbersOutcome(outcome.GetError());
}
}
void IssClient::ListOrganizationChannelNumbersAsync(const ListOrganizationChannelNumbersRequest& request, const ListOrganizationChannelNumbersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListOrganizationChannelNumbers(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListOrganizationChannelNumbersOutcomeCallable IssClient::ListOrganizationChannelNumbersCallable(const ListOrganizationChannelNumbersRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListOrganizationChannelNumbersOutcome()>>(
[this, request]()
{
return this->ListOrganizationChannelNumbers(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListOrganizationChannelsOutcome IssClient::ListOrganizationChannels(const ListOrganizationChannelsRequest &request)
{
auto outcome = MakeRequest(request, "ListOrganizationChannels");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListOrganizationChannelsResponse rsp = ListOrganizationChannelsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListOrganizationChannelsOutcome(rsp);
else
return ListOrganizationChannelsOutcome(o.GetError());
}
else
{
return ListOrganizationChannelsOutcome(outcome.GetError());
}
}
void IssClient::ListOrganizationChannelsAsync(const ListOrganizationChannelsRequest& request, const ListOrganizationChannelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListOrganizationChannels(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListOrganizationChannelsOutcomeCallable IssClient::ListOrganizationChannelsCallable(const ListOrganizationChannelsRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListOrganizationChannelsOutcome()>>(
[this, request]()
{
return this->ListOrganizationChannels(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListRecordBackupPlanDevicesOutcome IssClient::ListRecordBackupPlanDevices(const ListRecordBackupPlanDevicesRequest &request)
{
auto outcome = MakeRequest(request, "ListRecordBackupPlanDevices");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListRecordBackupPlanDevicesResponse rsp = ListRecordBackupPlanDevicesResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListRecordBackupPlanDevicesOutcome(rsp);
else
return ListRecordBackupPlanDevicesOutcome(o.GetError());
}
else
{
return ListRecordBackupPlanDevicesOutcome(outcome.GetError());
}
}
void IssClient::ListRecordBackupPlanDevicesAsync(const ListRecordBackupPlanDevicesRequest& request, const ListRecordBackupPlanDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListRecordBackupPlanDevices(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListRecordBackupPlanDevicesOutcomeCallable IssClient::ListRecordBackupPlanDevicesCallable(const ListRecordBackupPlanDevicesRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListRecordBackupPlanDevicesOutcome()>>(
[this, request]()
{
return this->ListRecordBackupPlanDevices(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListRecordBackupPlansOutcome IssClient::ListRecordBackupPlans(const ListRecordBackupPlansRequest &request)
{
auto outcome = MakeRequest(request, "ListRecordBackupPlans");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListRecordBackupPlansResponse rsp = ListRecordBackupPlansResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListRecordBackupPlansOutcome(rsp);
else
return ListRecordBackupPlansOutcome(o.GetError());
}
else
{
return ListRecordBackupPlansOutcome(outcome.GetError());
}
}
void IssClient::ListRecordBackupPlansAsync(const ListRecordBackupPlansRequest& request, const ListRecordBackupPlansAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListRecordBackupPlans(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListRecordBackupPlansOutcomeCallable IssClient::ListRecordBackupPlansCallable(const ListRecordBackupPlansRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListRecordBackupPlansOutcome()>>(
[this, request]()
{
return this->ListRecordBackupPlans(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListRecordBackupTemplatesOutcome IssClient::ListRecordBackupTemplates(const ListRecordBackupTemplatesRequest &request)
{
auto outcome = MakeRequest(request, "ListRecordBackupTemplates");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListRecordBackupTemplatesResponse rsp = ListRecordBackupTemplatesResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListRecordBackupTemplatesOutcome(rsp);
else
return ListRecordBackupTemplatesOutcome(o.GetError());
}
else
{
return ListRecordBackupTemplatesOutcome(outcome.GetError());
}
}
void IssClient::ListRecordBackupTemplatesAsync(const ListRecordBackupTemplatesRequest& request, const ListRecordBackupTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListRecordBackupTemplates(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListRecordBackupTemplatesOutcomeCallable IssClient::ListRecordBackupTemplatesCallable(const ListRecordBackupTemplatesRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListRecordBackupTemplatesOutcome()>>(
[this, request]()
{
return this->ListRecordBackupTemplates(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListRecordPlanChannelsOutcome IssClient::ListRecordPlanChannels(const ListRecordPlanChannelsRequest &request)
{
auto outcome = MakeRequest(request, "ListRecordPlanChannels");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListRecordPlanChannelsResponse rsp = ListRecordPlanChannelsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListRecordPlanChannelsOutcome(rsp);
else
return ListRecordPlanChannelsOutcome(o.GetError());
}
else
{
return ListRecordPlanChannelsOutcome(outcome.GetError());
}
}
void IssClient::ListRecordPlanChannelsAsync(const ListRecordPlanChannelsRequest& request, const ListRecordPlanChannelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListRecordPlanChannels(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListRecordPlanChannelsOutcomeCallable IssClient::ListRecordPlanChannelsCallable(const ListRecordPlanChannelsRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListRecordPlanChannelsOutcome()>>(
[this, request]()
{
return this->ListRecordPlanChannels(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListRecordPlanDevicesOutcome IssClient::ListRecordPlanDevices(const ListRecordPlanDevicesRequest &request)
{
auto outcome = MakeRequest(request, "ListRecordPlanDevices");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListRecordPlanDevicesResponse rsp = ListRecordPlanDevicesResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListRecordPlanDevicesOutcome(rsp);
else
return ListRecordPlanDevicesOutcome(o.GetError());
}
else
{
return ListRecordPlanDevicesOutcome(outcome.GetError());
}
}
void IssClient::ListRecordPlanDevicesAsync(const ListRecordPlanDevicesRequest& request, const ListRecordPlanDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListRecordPlanDevices(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListRecordPlanDevicesOutcomeCallable IssClient::ListRecordPlanDevicesCallable(const ListRecordPlanDevicesRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListRecordPlanDevicesOutcome()>>(
[this, request]()
{
return this->ListRecordPlanDevices(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListRecordPlansOutcome IssClient::ListRecordPlans(const ListRecordPlansRequest &request)
{
auto outcome = MakeRequest(request, "ListRecordPlans");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListRecordPlansResponse rsp = ListRecordPlansResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListRecordPlansOutcome(rsp);
else
return ListRecordPlansOutcome(o.GetError());
}
else
{
return ListRecordPlansOutcome(outcome.GetError());
}
}
void IssClient::ListRecordPlansAsync(const ListRecordPlansRequest& request, const ListRecordPlansAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListRecordPlans(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListRecordPlansOutcomeCallable IssClient::ListRecordPlansCallable(const ListRecordPlansRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListRecordPlansOutcome()>>(
[this, request]()
{
return this->ListRecordPlans(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListRecordRetrieveTasksOutcome IssClient::ListRecordRetrieveTasks(const ListRecordRetrieveTasksRequest &request)
{
auto outcome = MakeRequest(request, "ListRecordRetrieveTasks");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListRecordRetrieveTasksResponse rsp = ListRecordRetrieveTasksResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListRecordRetrieveTasksOutcome(rsp);
else
return ListRecordRetrieveTasksOutcome(o.GetError());
}
else
{
return ListRecordRetrieveTasksOutcome(outcome.GetError());
}
}
void IssClient::ListRecordRetrieveTasksAsync(const ListRecordRetrieveTasksRequest& request, const ListRecordRetrieveTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListRecordRetrieveTasks(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListRecordRetrieveTasksOutcomeCallable IssClient::ListRecordRetrieveTasksCallable(const ListRecordRetrieveTasksRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListRecordRetrieveTasksOutcome()>>(
[this, request]()
{
return this->ListRecordRetrieveTasks(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListRecordTemplatesOutcome IssClient::ListRecordTemplates(const ListRecordTemplatesRequest &request)
{
auto outcome = MakeRequest(request, "ListRecordTemplates");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListRecordTemplatesResponse rsp = ListRecordTemplatesResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListRecordTemplatesOutcome(rsp);
else
return ListRecordTemplatesOutcome(o.GetError());
}
else
{
return ListRecordTemplatesOutcome(outcome.GetError());
}
}
void IssClient::ListRecordTemplatesAsync(const ListRecordTemplatesRequest& request, const ListRecordTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListRecordTemplates(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListRecordTemplatesOutcomeCallable IssClient::ListRecordTemplatesCallable(const ListRecordTemplatesRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListRecordTemplatesOutcome()>>(
[this, request]()
{
return this->ListRecordTemplates(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListSubTasksOutcome IssClient::ListSubTasks(const ListSubTasksRequest &request)
{
auto outcome = MakeRequest(request, "ListSubTasks");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListSubTasksResponse rsp = ListSubTasksResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListSubTasksOutcome(rsp);
else
return ListSubTasksOutcome(o.GetError());
}
else
{
return ListSubTasksOutcome(outcome.GetError());
}
}
void IssClient::ListSubTasksAsync(const ListSubTasksRequest& request, const ListSubTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListSubTasks(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListSubTasksOutcomeCallable IssClient::ListSubTasksCallable(const ListSubTasksRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListSubTasksOutcome()>>(
[this, request]()
{
return this->ListSubTasks(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::ListTasksOutcome IssClient::ListTasks(const ListTasksRequest &request)
{
auto outcome = MakeRequest(request, "ListTasks");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ListTasksResponse rsp = ListTasksResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ListTasksOutcome(rsp);
else
return ListTasksOutcome(o.GetError());
}
else
{
return ListTasksOutcome(outcome.GetError());
}
}
void IssClient::ListTasksAsync(const ListTasksRequest& request, const ListTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ListTasks(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::ListTasksOutcomeCallable IssClient::ListTasksCallable(const ListTasksRequest &request)
{
auto task = std::make_shared<std::packaged_task<ListTasksOutcome()>>(
[this, request]()
{
return this->ListTasks(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::PlayRecordOutcome IssClient::PlayRecord(const PlayRecordRequest &request)
{
auto outcome = MakeRequest(request, "PlayRecord");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
PlayRecordResponse rsp = PlayRecordResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return PlayRecordOutcome(rsp);
else
return PlayRecordOutcome(o.GetError());
}
else
{
return PlayRecordOutcome(outcome.GetError());
}
}
void IssClient::PlayRecordAsync(const PlayRecordRequest& request, const PlayRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->PlayRecord(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::PlayRecordOutcomeCallable IssClient::PlayRecordCallable(const PlayRecordRequest &request)
{
auto task = std::make_shared<std::packaged_task<PlayRecordOutcome()>>(
[this, request]()
{
return this->PlayRecord(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::RefreshDeviceChannelOutcome IssClient::RefreshDeviceChannel(const RefreshDeviceChannelRequest &request)
{
auto outcome = MakeRequest(request, "RefreshDeviceChannel");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
RefreshDeviceChannelResponse rsp = RefreshDeviceChannelResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return RefreshDeviceChannelOutcome(rsp);
else
return RefreshDeviceChannelOutcome(o.GetError());
}
else
{
return RefreshDeviceChannelOutcome(outcome.GetError());
}
}
void IssClient::RefreshDeviceChannelAsync(const RefreshDeviceChannelRequest& request, const RefreshDeviceChannelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->RefreshDeviceChannel(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::RefreshDeviceChannelOutcomeCallable IssClient::RefreshDeviceChannelCallable(const RefreshDeviceChannelRequest &request)
{
auto task = std::make_shared<std::packaged_task<RefreshDeviceChannelOutcome()>>(
[this, request]()
{
return this->RefreshDeviceChannel(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateAITaskOutcome IssClient::UpdateAITask(const UpdateAITaskRequest &request)
{
auto outcome = MakeRequest(request, "UpdateAITask");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateAITaskResponse rsp = UpdateAITaskResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateAITaskOutcome(rsp);
else
return UpdateAITaskOutcome(o.GetError());
}
else
{
return UpdateAITaskOutcome(outcome.GetError());
}
}
void IssClient::UpdateAITaskAsync(const UpdateAITaskRequest& request, const UpdateAITaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateAITask(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateAITaskOutcomeCallable IssClient::UpdateAITaskCallable(const UpdateAITaskRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateAITaskOutcome()>>(
[this, request]()
{
return this->UpdateAITask(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateAITaskStatusOutcome IssClient::UpdateAITaskStatus(const UpdateAITaskStatusRequest &request)
{
auto outcome = MakeRequest(request, "UpdateAITaskStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateAITaskStatusResponse rsp = UpdateAITaskStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateAITaskStatusOutcome(rsp);
else
return UpdateAITaskStatusOutcome(o.GetError());
}
else
{
return UpdateAITaskStatusOutcome(outcome.GetError());
}
}
void IssClient::UpdateAITaskStatusAsync(const UpdateAITaskStatusRequest& request, const UpdateAITaskStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateAITaskStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateAITaskStatusOutcomeCallable IssClient::UpdateAITaskStatusCallable(const UpdateAITaskStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateAITaskStatusOutcome()>>(
[this, request]()
{
return this->UpdateAITaskStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateDeviceOrganizationOutcome IssClient::UpdateDeviceOrganization(const UpdateDeviceOrganizationRequest &request)
{
auto outcome = MakeRequest(request, "UpdateDeviceOrganization");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateDeviceOrganizationResponse rsp = UpdateDeviceOrganizationResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateDeviceOrganizationOutcome(rsp);
else
return UpdateDeviceOrganizationOutcome(o.GetError());
}
else
{
return UpdateDeviceOrganizationOutcome(outcome.GetError());
}
}
void IssClient::UpdateDeviceOrganizationAsync(const UpdateDeviceOrganizationRequest& request, const UpdateDeviceOrganizationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateDeviceOrganization(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateDeviceOrganizationOutcomeCallable IssClient::UpdateDeviceOrganizationCallable(const UpdateDeviceOrganizationRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateDeviceOrganizationOutcome()>>(
[this, request]()
{
return this->UpdateDeviceOrganization(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateDeviceStatusOutcome IssClient::UpdateDeviceStatus(const UpdateDeviceStatusRequest &request)
{
auto outcome = MakeRequest(request, "UpdateDeviceStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateDeviceStatusResponse rsp = UpdateDeviceStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateDeviceStatusOutcome(rsp);
else
return UpdateDeviceStatusOutcome(o.GetError());
}
else
{
return UpdateDeviceStatusOutcome(outcome.GetError());
}
}
void IssClient::UpdateDeviceStatusAsync(const UpdateDeviceStatusRequest& request, const UpdateDeviceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateDeviceStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateDeviceStatusOutcomeCallable IssClient::UpdateDeviceStatusCallable(const UpdateDeviceStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateDeviceStatusOutcome()>>(
[this, request]()
{
return this->UpdateDeviceStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateGatewayOutcome IssClient::UpdateGateway(const UpdateGatewayRequest &request)
{
auto outcome = MakeRequest(request, "UpdateGateway");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateGatewayResponse rsp = UpdateGatewayResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateGatewayOutcome(rsp);
else
return UpdateGatewayOutcome(o.GetError());
}
else
{
return UpdateGatewayOutcome(outcome.GetError());
}
}
void IssClient::UpdateGatewayAsync(const UpdateGatewayRequest& request, const UpdateGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateGateway(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateGatewayOutcomeCallable IssClient::UpdateGatewayCallable(const UpdateGatewayRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateGatewayOutcome()>>(
[this, request]()
{
return this->UpdateGateway(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateOrganizationOutcome IssClient::UpdateOrganization(const UpdateOrganizationRequest &request)
{
auto outcome = MakeRequest(request, "UpdateOrganization");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateOrganizationResponse rsp = UpdateOrganizationResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateOrganizationOutcome(rsp);
else
return UpdateOrganizationOutcome(o.GetError());
}
else
{
return UpdateOrganizationOutcome(outcome.GetError());
}
}
void IssClient::UpdateOrganizationAsync(const UpdateOrganizationRequest& request, const UpdateOrganizationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateOrganization(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateOrganizationOutcomeCallable IssClient::UpdateOrganizationCallable(const UpdateOrganizationRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateOrganizationOutcome()>>(
[this, request]()
{
return this->UpdateOrganization(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateRecordBackupPlanOutcome IssClient::UpdateRecordBackupPlan(const UpdateRecordBackupPlanRequest &request)
{
auto outcome = MakeRequest(request, "UpdateRecordBackupPlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateRecordBackupPlanResponse rsp = UpdateRecordBackupPlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateRecordBackupPlanOutcome(rsp);
else
return UpdateRecordBackupPlanOutcome(o.GetError());
}
else
{
return UpdateRecordBackupPlanOutcome(outcome.GetError());
}
}
void IssClient::UpdateRecordBackupPlanAsync(const UpdateRecordBackupPlanRequest& request, const UpdateRecordBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateRecordBackupPlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateRecordBackupPlanOutcomeCallable IssClient::UpdateRecordBackupPlanCallable(const UpdateRecordBackupPlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateRecordBackupPlanOutcome()>>(
[this, request]()
{
return this->UpdateRecordBackupPlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateRecordBackupTemplateOutcome IssClient::UpdateRecordBackupTemplate(const UpdateRecordBackupTemplateRequest &request)
{
auto outcome = MakeRequest(request, "UpdateRecordBackupTemplate");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateRecordBackupTemplateResponse rsp = UpdateRecordBackupTemplateResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateRecordBackupTemplateOutcome(rsp);
else
return UpdateRecordBackupTemplateOutcome(o.GetError());
}
else
{
return UpdateRecordBackupTemplateOutcome(outcome.GetError());
}
}
void IssClient::UpdateRecordBackupTemplateAsync(const UpdateRecordBackupTemplateRequest& request, const UpdateRecordBackupTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateRecordBackupTemplate(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateRecordBackupTemplateOutcomeCallable IssClient::UpdateRecordBackupTemplateCallable(const UpdateRecordBackupTemplateRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateRecordBackupTemplateOutcome()>>(
[this, request]()
{
return this->UpdateRecordBackupTemplate(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateRecordPlanOutcome IssClient::UpdateRecordPlan(const UpdateRecordPlanRequest &request)
{
auto outcome = MakeRequest(request, "UpdateRecordPlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateRecordPlanResponse rsp = UpdateRecordPlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateRecordPlanOutcome(rsp);
else
return UpdateRecordPlanOutcome(o.GetError());
}
else
{
return UpdateRecordPlanOutcome(outcome.GetError());
}
}
void IssClient::UpdateRecordPlanAsync(const UpdateRecordPlanRequest& request, const UpdateRecordPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateRecordPlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateRecordPlanOutcomeCallable IssClient::UpdateRecordPlanCallable(const UpdateRecordPlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateRecordPlanOutcome()>>(
[this, request]()
{
return this->UpdateRecordPlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateRecordTemplateOutcome IssClient::UpdateRecordTemplate(const UpdateRecordTemplateRequest &request)
{
auto outcome = MakeRequest(request, "UpdateRecordTemplate");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateRecordTemplateResponse rsp = UpdateRecordTemplateResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateRecordTemplateOutcome(rsp);
else
return UpdateRecordTemplateOutcome(o.GetError());
}
else
{
return UpdateRecordTemplateOutcome(outcome.GetError());
}
}
void IssClient::UpdateRecordTemplateAsync(const UpdateRecordTemplateRequest& request, const UpdateRecordTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateRecordTemplate(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateRecordTemplateOutcomeCallable IssClient::UpdateRecordTemplateCallable(const UpdateRecordTemplateRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateRecordTemplateOutcome()>>(
[this, request]()
{
return this->UpdateRecordTemplate(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpdateUserDeviceOutcome IssClient::UpdateUserDevice(const UpdateUserDeviceRequest &request)
{
auto outcome = MakeRequest(request, "UpdateUserDevice");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateUserDeviceResponse rsp = UpdateUserDeviceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateUserDeviceOutcome(rsp);
else
return UpdateUserDeviceOutcome(o.GetError());
}
else
{
return UpdateUserDeviceOutcome(outcome.GetError());
}
}
void IssClient::UpdateUserDeviceAsync(const UpdateUserDeviceRequest& request, const UpdateUserDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateUserDevice(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpdateUserDeviceOutcomeCallable IssClient::UpdateUserDeviceCallable(const UpdateUserDeviceRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateUserDeviceOutcome()>>(
[this, request]()
{
return this->UpdateUserDevice(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
IssClient::UpgradeGatewayOutcome IssClient::UpgradeGateway(const UpgradeGatewayRequest &request)
{
auto outcome = MakeRequest(request, "UpgradeGateway");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpgradeGatewayResponse rsp = UpgradeGatewayResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpgradeGatewayOutcome(rsp);
else
return UpgradeGatewayOutcome(o.GetError());
}
else
{
return UpgradeGatewayOutcome(outcome.GetError());
}
}
void IssClient::UpgradeGatewayAsync(const UpgradeGatewayRequest& request, const UpgradeGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpgradeGateway(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
IssClient::UpgradeGatewayOutcomeCallable IssClient::UpgradeGatewayCallable(const UpgradeGatewayRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpgradeGatewayOutcome()>>(
[this, request]()
{
return this->UpgradeGateway(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。