1494 lines
50 KiB
C++
1494 lines
50 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/pts/PTSClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::PTS;
|
|
using namespace AlibabaCloud::PTS::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "PTS";
|
|
}
|
|
|
|
PTSClient::PTSClient(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, "");
|
|
}
|
|
|
|
PTSClient::PTSClient(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, "");
|
|
}
|
|
|
|
PTSClient::PTSClient(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, "");
|
|
}
|
|
|
|
PTSClient::~PTSClient()
|
|
{}
|
|
|
|
PTSClient::AdjustJMeterSceneSpeedOutcome PTSClient::adjustJMeterSceneSpeed(const AdjustJMeterSceneSpeedRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return AdjustJMeterSceneSpeedOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return AdjustJMeterSceneSpeedOutcome(AdjustJMeterSceneSpeedResult(outcome.result()));
|
|
else
|
|
return AdjustJMeterSceneSpeedOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::adjustJMeterSceneSpeedAsync(const AdjustJMeterSceneSpeedRequest& request, const AdjustJMeterSceneSpeedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, adjustJMeterSceneSpeed(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::AdjustJMeterSceneSpeedOutcomeCallable PTSClient::adjustJMeterSceneSpeedCallable(const AdjustJMeterSceneSpeedRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<AdjustJMeterSceneSpeedOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->adjustJMeterSceneSpeed(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::CreatePtsSceneOutcome PTSClient::createPtsScene(const CreatePtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreatePtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreatePtsSceneOutcome(CreatePtsSceneResult(outcome.result()));
|
|
else
|
|
return CreatePtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::createPtsSceneAsync(const CreatePtsSceneRequest& request, const CreatePtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createPtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::CreatePtsSceneOutcomeCallable PTSClient::createPtsSceneCallable(const CreatePtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreatePtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createPtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::CreatePtsSceneBaseLineFromReportOutcome PTSClient::createPtsSceneBaseLineFromReport(const CreatePtsSceneBaseLineFromReportRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreatePtsSceneBaseLineFromReportOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreatePtsSceneBaseLineFromReportOutcome(CreatePtsSceneBaseLineFromReportResult(outcome.result()));
|
|
else
|
|
return CreatePtsSceneBaseLineFromReportOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::createPtsSceneBaseLineFromReportAsync(const CreatePtsSceneBaseLineFromReportRequest& request, const CreatePtsSceneBaseLineFromReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createPtsSceneBaseLineFromReport(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::CreatePtsSceneBaseLineFromReportOutcomeCallable PTSClient::createPtsSceneBaseLineFromReportCallable(const CreatePtsSceneBaseLineFromReportRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreatePtsSceneBaseLineFromReportOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createPtsSceneBaseLineFromReport(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::DeletePtsSceneOutcome PTSClient::deletePtsScene(const DeletePtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeletePtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeletePtsSceneOutcome(DeletePtsSceneResult(outcome.result()));
|
|
else
|
|
return DeletePtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::deletePtsSceneAsync(const DeletePtsSceneRequest& request, const DeletePtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deletePtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::DeletePtsSceneOutcomeCallable PTSClient::deletePtsSceneCallable(const DeletePtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeletePtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deletePtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::DeletePtsSceneBaseLineOutcome PTSClient::deletePtsSceneBaseLine(const DeletePtsSceneBaseLineRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeletePtsSceneBaseLineOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeletePtsSceneBaseLineOutcome(DeletePtsSceneBaseLineResult(outcome.result()));
|
|
else
|
|
return DeletePtsSceneBaseLineOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::deletePtsSceneBaseLineAsync(const DeletePtsSceneBaseLineRequest& request, const DeletePtsSceneBaseLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deletePtsSceneBaseLine(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::DeletePtsSceneBaseLineOutcomeCallable PTSClient::deletePtsSceneBaseLineCallable(const DeletePtsSceneBaseLineRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeletePtsSceneBaseLineOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deletePtsSceneBaseLine(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::DeletePtsScenesOutcome PTSClient::deletePtsScenes(const DeletePtsScenesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeletePtsScenesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeletePtsScenesOutcome(DeletePtsScenesResult(outcome.result()));
|
|
else
|
|
return DeletePtsScenesOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::deletePtsScenesAsync(const DeletePtsScenesRequest& request, const DeletePtsScenesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deletePtsScenes(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::DeletePtsScenesOutcomeCallable PTSClient::deletePtsScenesCallable(const DeletePtsScenesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeletePtsScenesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deletePtsScenes(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetAllRegionsOutcome PTSClient::getAllRegions(const GetAllRegionsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetAllRegionsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetAllRegionsOutcome(GetAllRegionsResult(outcome.result()));
|
|
else
|
|
return GetAllRegionsOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getAllRegionsAsync(const GetAllRegionsRequest& request, const GetAllRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getAllRegions(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetAllRegionsOutcomeCallable PTSClient::getAllRegionsCallable(const GetAllRegionsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetAllRegionsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getAllRegions(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetJMeterLogsOutcome PTSClient::getJMeterLogs(const GetJMeterLogsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetJMeterLogsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetJMeterLogsOutcome(GetJMeterLogsResult(outcome.result()));
|
|
else
|
|
return GetJMeterLogsOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getJMeterLogsAsync(const GetJMeterLogsRequest& request, const GetJMeterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getJMeterLogs(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetJMeterLogsOutcomeCallable PTSClient::getJMeterLogsCallable(const GetJMeterLogsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetJMeterLogsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getJMeterLogs(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetJMeterSampleMetricsOutcome PTSClient::getJMeterSampleMetrics(const GetJMeterSampleMetricsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetJMeterSampleMetricsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetJMeterSampleMetricsOutcome(GetJMeterSampleMetricsResult(outcome.result()));
|
|
else
|
|
return GetJMeterSampleMetricsOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getJMeterSampleMetricsAsync(const GetJMeterSampleMetricsRequest& request, const GetJMeterSampleMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getJMeterSampleMetrics(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetJMeterSampleMetricsOutcomeCallable PTSClient::getJMeterSampleMetricsCallable(const GetJMeterSampleMetricsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetJMeterSampleMetricsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getJMeterSampleMetrics(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetJMeterSamplingLogsOutcome PTSClient::getJMeterSamplingLogs(const GetJMeterSamplingLogsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetJMeterSamplingLogsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetJMeterSamplingLogsOutcome(GetJMeterSamplingLogsResult(outcome.result()));
|
|
else
|
|
return GetJMeterSamplingLogsOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getJMeterSamplingLogsAsync(const GetJMeterSamplingLogsRequest& request, const GetJMeterSamplingLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getJMeterSamplingLogs(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetJMeterSamplingLogsOutcomeCallable PTSClient::getJMeterSamplingLogsCallable(const GetJMeterSamplingLogsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetJMeterSamplingLogsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getJMeterSamplingLogs(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetJMeterSceneRunningDataOutcome PTSClient::getJMeterSceneRunningData(const GetJMeterSceneRunningDataRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetJMeterSceneRunningDataOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetJMeterSceneRunningDataOutcome(GetJMeterSceneRunningDataResult(outcome.result()));
|
|
else
|
|
return GetJMeterSceneRunningDataOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getJMeterSceneRunningDataAsync(const GetJMeterSceneRunningDataRequest& request, const GetJMeterSceneRunningDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getJMeterSceneRunningData(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetJMeterSceneRunningDataOutcomeCallable PTSClient::getJMeterSceneRunningDataCallable(const GetJMeterSceneRunningDataRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetJMeterSceneRunningDataOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getJMeterSceneRunningData(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetOpenJMeterSceneOutcome PTSClient::getOpenJMeterScene(const GetOpenJMeterSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetOpenJMeterSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetOpenJMeterSceneOutcome(GetOpenJMeterSceneResult(outcome.result()));
|
|
else
|
|
return GetOpenJMeterSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getOpenJMeterSceneAsync(const GetOpenJMeterSceneRequest& request, const GetOpenJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getOpenJMeterScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetOpenJMeterSceneOutcomeCallable PTSClient::getOpenJMeterSceneCallable(const GetOpenJMeterSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetOpenJMeterSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getOpenJMeterScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetPtsReportDetailsOutcome PTSClient::getPtsReportDetails(const GetPtsReportDetailsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetPtsReportDetailsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetPtsReportDetailsOutcome(GetPtsReportDetailsResult(outcome.result()));
|
|
else
|
|
return GetPtsReportDetailsOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getPtsReportDetailsAsync(const GetPtsReportDetailsRequest& request, const GetPtsReportDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getPtsReportDetails(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetPtsReportDetailsOutcomeCallable PTSClient::getPtsReportDetailsCallable(const GetPtsReportDetailsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetPtsReportDetailsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getPtsReportDetails(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetPtsReportsBySceneIdOutcome PTSClient::getPtsReportsBySceneId(const GetPtsReportsBySceneIdRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetPtsReportsBySceneIdOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetPtsReportsBySceneIdOutcome(GetPtsReportsBySceneIdResult(outcome.result()));
|
|
else
|
|
return GetPtsReportsBySceneIdOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getPtsReportsBySceneIdAsync(const GetPtsReportsBySceneIdRequest& request, const GetPtsReportsBySceneIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getPtsReportsBySceneId(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetPtsReportsBySceneIdOutcomeCallable PTSClient::getPtsReportsBySceneIdCallable(const GetPtsReportsBySceneIdRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetPtsReportsBySceneIdOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getPtsReportsBySceneId(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetPtsSceneOutcome PTSClient::getPtsScene(const GetPtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetPtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetPtsSceneOutcome(GetPtsSceneResult(outcome.result()));
|
|
else
|
|
return GetPtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getPtsSceneAsync(const GetPtsSceneRequest& request, const GetPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getPtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetPtsSceneOutcomeCallable PTSClient::getPtsSceneCallable(const GetPtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetPtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getPtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetPtsSceneBaseLineOutcome PTSClient::getPtsSceneBaseLine(const GetPtsSceneBaseLineRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetPtsSceneBaseLineOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetPtsSceneBaseLineOutcome(GetPtsSceneBaseLineResult(outcome.result()));
|
|
else
|
|
return GetPtsSceneBaseLineOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getPtsSceneBaseLineAsync(const GetPtsSceneBaseLineRequest& request, const GetPtsSceneBaseLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getPtsSceneBaseLine(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetPtsSceneBaseLineOutcomeCallable PTSClient::getPtsSceneBaseLineCallable(const GetPtsSceneBaseLineRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetPtsSceneBaseLineOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getPtsSceneBaseLine(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetPtsSceneRunningDataOutcome PTSClient::getPtsSceneRunningData(const GetPtsSceneRunningDataRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetPtsSceneRunningDataOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetPtsSceneRunningDataOutcome(GetPtsSceneRunningDataResult(outcome.result()));
|
|
else
|
|
return GetPtsSceneRunningDataOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getPtsSceneRunningDataAsync(const GetPtsSceneRunningDataRequest& request, const GetPtsSceneRunningDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getPtsSceneRunningData(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetPtsSceneRunningDataOutcomeCallable PTSClient::getPtsSceneRunningDataCallable(const GetPtsSceneRunningDataRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetPtsSceneRunningDataOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getPtsSceneRunningData(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetPtsSceneRunningStatusOutcome PTSClient::getPtsSceneRunningStatus(const GetPtsSceneRunningStatusRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetPtsSceneRunningStatusOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetPtsSceneRunningStatusOutcome(GetPtsSceneRunningStatusResult(outcome.result()));
|
|
else
|
|
return GetPtsSceneRunningStatusOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getPtsSceneRunningStatusAsync(const GetPtsSceneRunningStatusRequest& request, const GetPtsSceneRunningStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getPtsSceneRunningStatus(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetPtsSceneRunningStatusOutcomeCallable PTSClient::getPtsSceneRunningStatusCallable(const GetPtsSceneRunningStatusRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetPtsSceneRunningStatusOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getPtsSceneRunningStatus(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetUserVpcSecurityGroupOutcome PTSClient::getUserVpcSecurityGroup(const GetUserVpcSecurityGroupRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetUserVpcSecurityGroupOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetUserVpcSecurityGroupOutcome(GetUserVpcSecurityGroupResult(outcome.result()));
|
|
else
|
|
return GetUserVpcSecurityGroupOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getUserVpcSecurityGroupAsync(const GetUserVpcSecurityGroupRequest& request, const GetUserVpcSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getUserVpcSecurityGroup(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetUserVpcSecurityGroupOutcomeCallable PTSClient::getUserVpcSecurityGroupCallable(const GetUserVpcSecurityGroupRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetUserVpcSecurityGroupOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getUserVpcSecurityGroup(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetUserVpcVSwitchOutcome PTSClient::getUserVpcVSwitch(const GetUserVpcVSwitchRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetUserVpcVSwitchOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetUserVpcVSwitchOutcome(GetUserVpcVSwitchResult(outcome.result()));
|
|
else
|
|
return GetUserVpcVSwitchOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getUserVpcVSwitchAsync(const GetUserVpcVSwitchRequest& request, const GetUserVpcVSwitchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getUserVpcVSwitch(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetUserVpcVSwitchOutcomeCallable PTSClient::getUserVpcVSwitchCallable(const GetUserVpcVSwitchRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetUserVpcVSwitchOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getUserVpcVSwitch(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::GetUserVpcsOutcome PTSClient::getUserVpcs(const GetUserVpcsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetUserVpcsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetUserVpcsOutcome(GetUserVpcsResult(outcome.result()));
|
|
else
|
|
return GetUserVpcsOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::getUserVpcsAsync(const GetUserVpcsRequest& request, const GetUserVpcsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getUserVpcs(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::GetUserVpcsOutcomeCallable PTSClient::getUserVpcsCallable(const GetUserVpcsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetUserVpcsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getUserVpcs(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::ListEnvsOutcome PTSClient::listEnvs(const ListEnvsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListEnvsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListEnvsOutcome(ListEnvsResult(outcome.result()));
|
|
else
|
|
return ListEnvsOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::listEnvsAsync(const ListEnvsRequest& request, const ListEnvsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listEnvs(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::ListEnvsOutcomeCallable PTSClient::listEnvsCallable(const ListEnvsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListEnvsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listEnvs(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::ListJMeterReportsOutcome PTSClient::listJMeterReports(const ListJMeterReportsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListJMeterReportsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListJMeterReportsOutcome(ListJMeterReportsResult(outcome.result()));
|
|
else
|
|
return ListJMeterReportsOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::listJMeterReportsAsync(const ListJMeterReportsRequest& request, const ListJMeterReportsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listJMeterReports(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::ListJMeterReportsOutcomeCallable PTSClient::listJMeterReportsCallable(const ListJMeterReportsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListJMeterReportsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listJMeterReports(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::ListOpenJMeterScenesOutcome PTSClient::listOpenJMeterScenes(const ListOpenJMeterScenesRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListOpenJMeterScenesOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListOpenJMeterScenesOutcome(ListOpenJMeterScenesResult(outcome.result()));
|
|
else
|
|
return ListOpenJMeterScenesOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::listOpenJMeterScenesAsync(const ListOpenJMeterScenesRequest& request, const ListOpenJMeterScenesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listOpenJMeterScenes(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::ListOpenJMeterScenesOutcomeCallable PTSClient::listOpenJMeterScenesCallable(const ListOpenJMeterScenesRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListOpenJMeterScenesOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listOpenJMeterScenes(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::ListPtsSceneOutcome PTSClient::listPtsScene(const ListPtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListPtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListPtsSceneOutcome(ListPtsSceneResult(outcome.result()));
|
|
else
|
|
return ListPtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::listPtsSceneAsync(const ListPtsSceneRequest& request, const ListPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listPtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::ListPtsSceneOutcomeCallable PTSClient::listPtsSceneCallable(const ListPtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListPtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listPtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::ModifyPtsSceneOutcome PTSClient::modifyPtsScene(const ModifyPtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ModifyPtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ModifyPtsSceneOutcome(ModifyPtsSceneResult(outcome.result()));
|
|
else
|
|
return ModifyPtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::modifyPtsSceneAsync(const ModifyPtsSceneRequest& request, const ModifyPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, modifyPtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::ModifyPtsSceneOutcomeCallable PTSClient::modifyPtsSceneCallable(const ModifyPtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ModifyPtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->modifyPtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::RemoveEnvOutcome PTSClient::removeEnv(const RemoveEnvRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RemoveEnvOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RemoveEnvOutcome(RemoveEnvResult(outcome.result()));
|
|
else
|
|
return RemoveEnvOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::removeEnvAsync(const RemoveEnvRequest& request, const RemoveEnvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, removeEnv(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::RemoveEnvOutcomeCallable PTSClient::removeEnvCallable(const RemoveEnvRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RemoveEnvOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->removeEnv(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::RemoveOpenJMeterSceneOutcome PTSClient::removeOpenJMeterScene(const RemoveOpenJMeterSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return RemoveOpenJMeterSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return RemoveOpenJMeterSceneOutcome(RemoveOpenJMeterSceneResult(outcome.result()));
|
|
else
|
|
return RemoveOpenJMeterSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::removeOpenJMeterSceneAsync(const RemoveOpenJMeterSceneRequest& request, const RemoveOpenJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, removeOpenJMeterScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::RemoveOpenJMeterSceneOutcomeCallable PTSClient::removeOpenJMeterSceneCallable(const RemoveOpenJMeterSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<RemoveOpenJMeterSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->removeOpenJMeterScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::SaveEnvOutcome PTSClient::saveEnv(const SaveEnvRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SaveEnvOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SaveEnvOutcome(SaveEnvResult(outcome.result()));
|
|
else
|
|
return SaveEnvOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::saveEnvAsync(const SaveEnvRequest& request, const SaveEnvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, saveEnv(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::SaveEnvOutcomeCallable PTSClient::saveEnvCallable(const SaveEnvRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SaveEnvOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->saveEnv(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::SaveOpenJMeterSceneOutcome PTSClient::saveOpenJMeterScene(const SaveOpenJMeterSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SaveOpenJMeterSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SaveOpenJMeterSceneOutcome(SaveOpenJMeterSceneResult(outcome.result()));
|
|
else
|
|
return SaveOpenJMeterSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::saveOpenJMeterSceneAsync(const SaveOpenJMeterSceneRequest& request, const SaveOpenJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, saveOpenJMeterScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::SaveOpenJMeterSceneOutcomeCallable PTSClient::saveOpenJMeterSceneCallable(const SaveOpenJMeterSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SaveOpenJMeterSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->saveOpenJMeterScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::SavePtsSceneOutcome PTSClient::savePtsScene(const SavePtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SavePtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SavePtsSceneOutcome(SavePtsSceneResult(outcome.result()));
|
|
else
|
|
return SavePtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::savePtsSceneAsync(const SavePtsSceneRequest& request, const SavePtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, savePtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::SavePtsSceneOutcomeCallable PTSClient::savePtsSceneCallable(const SavePtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SavePtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->savePtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::StartDebugPtsSceneOutcome PTSClient::startDebugPtsScene(const StartDebugPtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StartDebugPtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StartDebugPtsSceneOutcome(StartDebugPtsSceneResult(outcome.result()));
|
|
else
|
|
return StartDebugPtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::startDebugPtsSceneAsync(const StartDebugPtsSceneRequest& request, const StartDebugPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, startDebugPtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::StartDebugPtsSceneOutcomeCallable PTSClient::startDebugPtsSceneCallable(const StartDebugPtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StartDebugPtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->startDebugPtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::StartDebuggingJMeterSceneOutcome PTSClient::startDebuggingJMeterScene(const StartDebuggingJMeterSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StartDebuggingJMeterSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StartDebuggingJMeterSceneOutcome(StartDebuggingJMeterSceneResult(outcome.result()));
|
|
else
|
|
return StartDebuggingJMeterSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::startDebuggingJMeterSceneAsync(const StartDebuggingJMeterSceneRequest& request, const StartDebuggingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, startDebuggingJMeterScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::StartDebuggingJMeterSceneOutcomeCallable PTSClient::startDebuggingJMeterSceneCallable(const StartDebuggingJMeterSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StartDebuggingJMeterSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->startDebuggingJMeterScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::StartPtsSceneOutcome PTSClient::startPtsScene(const StartPtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StartPtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StartPtsSceneOutcome(StartPtsSceneResult(outcome.result()));
|
|
else
|
|
return StartPtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::startPtsSceneAsync(const StartPtsSceneRequest& request, const StartPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, startPtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::StartPtsSceneOutcomeCallable PTSClient::startPtsSceneCallable(const StartPtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StartPtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->startPtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::StartTestingJMeterSceneOutcome PTSClient::startTestingJMeterScene(const StartTestingJMeterSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StartTestingJMeterSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StartTestingJMeterSceneOutcome(StartTestingJMeterSceneResult(outcome.result()));
|
|
else
|
|
return StartTestingJMeterSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::startTestingJMeterSceneAsync(const StartTestingJMeterSceneRequest& request, const StartTestingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, startTestingJMeterScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::StartTestingJMeterSceneOutcomeCallable PTSClient::startTestingJMeterSceneCallable(const StartTestingJMeterSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StartTestingJMeterSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->startTestingJMeterScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::StopDebugPtsSceneOutcome PTSClient::stopDebugPtsScene(const StopDebugPtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StopDebugPtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StopDebugPtsSceneOutcome(StopDebugPtsSceneResult(outcome.result()));
|
|
else
|
|
return StopDebugPtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::stopDebugPtsSceneAsync(const StopDebugPtsSceneRequest& request, const StopDebugPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, stopDebugPtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::StopDebugPtsSceneOutcomeCallable PTSClient::stopDebugPtsSceneCallable(const StopDebugPtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StopDebugPtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->stopDebugPtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::StopDebuggingJMeterSceneOutcome PTSClient::stopDebuggingJMeterScene(const StopDebuggingJMeterSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StopDebuggingJMeterSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StopDebuggingJMeterSceneOutcome(StopDebuggingJMeterSceneResult(outcome.result()));
|
|
else
|
|
return StopDebuggingJMeterSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::stopDebuggingJMeterSceneAsync(const StopDebuggingJMeterSceneRequest& request, const StopDebuggingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, stopDebuggingJMeterScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::StopDebuggingJMeterSceneOutcomeCallable PTSClient::stopDebuggingJMeterSceneCallable(const StopDebuggingJMeterSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StopDebuggingJMeterSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->stopDebuggingJMeterScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::StopPtsSceneOutcome PTSClient::stopPtsScene(const StopPtsSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StopPtsSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StopPtsSceneOutcome(StopPtsSceneResult(outcome.result()));
|
|
else
|
|
return StopPtsSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::stopPtsSceneAsync(const StopPtsSceneRequest& request, const StopPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, stopPtsScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::StopPtsSceneOutcomeCallable PTSClient::stopPtsSceneCallable(const StopPtsSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StopPtsSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->stopPtsScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::StopTestingJMeterSceneOutcome PTSClient::stopTestingJMeterScene(const StopTestingJMeterSceneRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return StopTestingJMeterSceneOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return StopTestingJMeterSceneOutcome(StopTestingJMeterSceneResult(outcome.result()));
|
|
else
|
|
return StopTestingJMeterSceneOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::stopTestingJMeterSceneAsync(const StopTestingJMeterSceneRequest& request, const StopTestingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, stopTestingJMeterScene(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::StopTestingJMeterSceneOutcomeCallable PTSClient::stopTestingJMeterSceneCallable(const StopTestingJMeterSceneRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<StopTestingJMeterSceneOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->stopTestingJMeterScene(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
PTSClient::UpdatePtsSceneBaseLineOutcome PTSClient::updatePtsSceneBaseLine(const UpdatePtsSceneBaseLineRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return UpdatePtsSceneBaseLineOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return UpdatePtsSceneBaseLineOutcome(UpdatePtsSceneBaseLineResult(outcome.result()));
|
|
else
|
|
return UpdatePtsSceneBaseLineOutcome(outcome.error());
|
|
}
|
|
|
|
void PTSClient::updatePtsSceneBaseLineAsync(const UpdatePtsSceneBaseLineRequest& request, const UpdatePtsSceneBaseLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, updatePtsSceneBaseLine(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
PTSClient::UpdatePtsSceneBaseLineOutcomeCallable PTSClient::updatePtsSceneBaseLineCallable(const UpdatePtsSceneBaseLineRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<UpdatePtsSceneBaseLineOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->updatePtsSceneBaseLine(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|