702 lines
22 KiB
C++
702 lines
22 KiB
C++
/*
|
|
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <alibabacloud/tdsr/TdsrClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::Tdsr;
|
|
using namespace AlibabaCloud::Tdsr::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "tdsr";
|
|
}
|
|
|
|
TdsrClient::TdsrClient(const Credentials &credentials, const ClientConfiguration &configuration) :
|
|
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
|
|
}
|
|
|
|
TdsrClient::TdsrClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
|
|
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
|
|
}
|
|
|
|
TdsrClient::TdsrClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
|
|
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
|
|
{
|
|
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
|
|
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
|
|
}
|
|
|
|
TdsrClient::~TdsrClient()
|
|
{}
|
|
|
|
TdsrClient::CheckPermissionOutcome TdsrClient::checkPermission(const CheckPermissionRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CheckPermissionOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CheckPermissionOutcome(CheckPermissionResult(outcome.result()));
|
|
else
|
|
return CheckPermissionOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::checkPermissionAsync(const CheckPermissionRequest& request, const CheckPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, checkPermission(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::CheckPermissionOutcomeCallable TdsrClient::checkPermissionCallable(const CheckPermissionRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CheckPermissionOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->checkPermission(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::CheckResourceOutcome TdsrClient::checkResource(const CheckResourceRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CheckResourceOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CheckResourceOutcome(CheckResourceResult(outcome.result()));
|
|
else
|
|
return CheckResourceOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::checkResourceAsync(const CheckResourceRequest& request, const CheckResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, checkResource(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::CheckResourceOutcomeCallable TdsrClient::checkResourceCallable(const CheckResourceRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CheckResourceOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->checkResource(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::CreateProjectOutcome TdsrClient::createProject(const CreateProjectRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateProjectOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateProjectOutcome(CreateProjectResult(outcome.result()));
|
|
else
|
|
return CreateProjectOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::createProjectAsync(const CreateProjectRequest& request, const CreateProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createProject(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::CreateProjectOutcomeCallable TdsrClient::createProjectCallable(const CreateProjectRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateProjectOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createProject(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::CreateSceneOutcome TdsrClient::createScene(const CreateSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateSceneOutcome(CreateSceneResult(outcome.result()));
|
|
else
|
|
return CreateSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::createSceneAsync(const CreateSceneRequest& request, const CreateSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::CreateSceneOutcomeCallable TdsrClient::createSceneCallable(const CreateSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::DeleteFileOutcome TdsrClient::deleteFile(const DeleteFileRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteFileOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteFileOutcome(DeleteFileResult(outcome.result()));
|
|
else
|
|
return DeleteFileOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::deleteFileAsync(const DeleteFileRequest& request, const DeleteFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteFile(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::DeleteFileOutcomeCallable TdsrClient::deleteFileCallable(const DeleteFileRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteFileOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteFile(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::DeleteProjectOutcome TdsrClient::deleteProject(const DeleteProjectRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteProjectOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteProjectOutcome(DeleteProjectResult(outcome.result()));
|
|
else
|
|
return DeleteProjectOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::deleteProjectAsync(const DeleteProjectRequest& request, const DeleteProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteProject(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::DeleteProjectOutcomeCallable TdsrClient::deleteProjectCallable(const DeleteProjectRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteProjectOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteProject(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::GetHotspotConfigOutcome TdsrClient::getHotspotConfig(const GetHotspotConfigRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetHotspotConfigOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetHotspotConfigOutcome(GetHotspotConfigResult(outcome.result()));
|
|
else
|
|
return GetHotspotConfigOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::getHotspotConfigAsync(const GetHotspotConfigRequest& request, const GetHotspotConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getHotspotConfig(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::GetHotspotConfigOutcomeCallable TdsrClient::getHotspotConfigCallable(const GetHotspotConfigRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetHotspotConfigOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getHotspotConfig(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::GetHotspotTagOutcome TdsrClient::getHotspotTag(const GetHotspotTagRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetHotspotTagOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetHotspotTagOutcome(GetHotspotTagResult(outcome.result()));
|
|
else
|
|
return GetHotspotTagOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::getHotspotTagAsync(const GetHotspotTagRequest& request, const GetHotspotTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getHotspotTag(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::GetHotspotTagOutcomeCallable TdsrClient::getHotspotTagCallable(const GetHotspotTagRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetHotspotTagOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getHotspotTag(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::GetPolicyOutcome TdsrClient::getPolicy(const GetPolicyRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetPolicyOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetPolicyOutcome(GetPolicyResult(outcome.result()));
|
|
else
|
|
return GetPolicyOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::getPolicyAsync(const GetPolicyRequest& request, const GetPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getPolicy(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::GetPolicyOutcomeCallable TdsrClient::getPolicyCallable(const GetPolicyRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetPolicyOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getPolicy(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::GetSceneDataOutcome TdsrClient::getSceneData(const GetSceneDataRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetSceneDataOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetSceneDataOutcome(GetSceneDataResult(outcome.result()));
|
|
else
|
|
return GetSceneDataOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::getSceneDataAsync(const GetSceneDataRequest& request, const GetSceneDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getSceneData(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::GetSceneDataOutcomeCallable TdsrClient::getSceneDataCallable(const GetSceneDataRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetSceneDataOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getSceneData(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::GetSceneListOutcome TdsrClient::getSceneList(const GetSceneListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetSceneListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetSceneListOutcome(GetSceneListResult(outcome.result()));
|
|
else
|
|
return GetSceneListOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::getSceneListAsync(const GetSceneListRequest& request, const GetSceneListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getSceneList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::GetSceneListOutcomeCallable TdsrClient::getSceneListCallable(const GetSceneListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetSceneListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getSceneList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::GetWindowConfigOutcome TdsrClient::getWindowConfig(const GetWindowConfigRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetWindowConfigOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetWindowConfigOutcome(GetWindowConfigResult(outcome.result()));
|
|
else
|
|
return GetWindowConfigOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::getWindowConfigAsync(const GetWindowConfigRequest& request, const GetWindowConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getWindowConfig(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::GetWindowConfigOutcomeCallable TdsrClient::getWindowConfigCallable(const GetWindowConfigRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetWindowConfigOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getWindowConfig(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::ListMainScenesOutcome TdsrClient::listMainScenes(const ListMainScenesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListMainScenesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListMainScenesOutcome(ListMainScenesResult(outcome.result()));
|
|
else
|
|
return ListMainScenesOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::listMainScenesAsync(const ListMainScenesRequest& request, const ListMainScenesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listMainScenes(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::ListMainScenesOutcomeCallable TdsrClient::listMainScenesCallable(const ListMainScenesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListMainScenesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listMainScenes(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::ListScenesOutcome TdsrClient::listScenes(const ListScenesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListScenesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListScenesOutcome(ListScenesResult(outcome.result()));
|
|
else
|
|
return ListScenesOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::listScenesAsync(const ListScenesRequest& request, const ListScenesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listScenes(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::ListScenesOutcomeCallable TdsrClient::listScenesCallable(const ListScenesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListScenesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listScenes(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::PublishHotspotOutcome TdsrClient::publishHotspot(const PublishHotspotRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return PublishHotspotOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return PublishHotspotOutcome(PublishHotspotResult(outcome.result()));
|
|
else
|
|
return PublishHotspotOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::publishHotspotAsync(const PublishHotspotRequest& request, const PublishHotspotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, publishHotspot(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::PublishHotspotOutcomeCallable TdsrClient::publishHotspotCallable(const PublishHotspotRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<PublishHotspotOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->publishHotspot(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::SaveFileOutcome TdsrClient::saveFile(const SaveFileRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SaveFileOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SaveFileOutcome(SaveFileResult(outcome.result()));
|
|
else
|
|
return SaveFileOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::saveFileAsync(const SaveFileRequest& request, const SaveFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, saveFile(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::SaveFileOutcomeCallable TdsrClient::saveFileCallable(const SaveFileRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SaveFileOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->saveFile(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::SaveHotspotConfigOutcome TdsrClient::saveHotspotConfig(const SaveHotspotConfigRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SaveHotspotConfigOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SaveHotspotConfigOutcome(SaveHotspotConfigResult(outcome.result()));
|
|
else
|
|
return SaveHotspotConfigOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::saveHotspotConfigAsync(const SaveHotspotConfigRequest& request, const SaveHotspotConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, saveHotspotConfig(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::SaveHotspotConfigOutcomeCallable TdsrClient::saveHotspotConfigCallable(const SaveHotspotConfigRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SaveHotspotConfigOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->saveHotspotConfig(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
TdsrClient::SaveHotspotTagOutcome TdsrClient::saveHotspotTag(const SaveHotspotTagRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SaveHotspotTagOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SaveHotspotTagOutcome(SaveHotspotTagResult(outcome.result()));
|
|
else
|
|
return SaveHotspotTagOutcome(outcome.error());
|
|
}
|
|
|
|
void TdsrClient::saveHotspotTagAsync(const SaveHotspotTagRequest& request, const SaveHotspotTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, saveHotspotTag(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
TdsrClient::SaveHotspotTagOutcomeCallable TdsrClient::saveHotspotTagCallable(const SaveHotspotTagRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SaveHotspotTagOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->saveHotspotTag(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|