代码拉取完成，页面将自动刷新
/*
* 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/apigateway/v20180808/ApigatewayClient.h>
#include <tencentcloud/core/Executor.h>
#include <tencentcloud/core/Runnable.h>
using namespace TencentCloud;
using namespace TencentCloud::Apigateway::V20180808;
using namespace TencentCloud::Apigateway::V20180808::Model;
using namespace std;
namespace
{
const string VERSION = "2018-08-08";
const string ENDPOINT = "apigateway.tencentcloudapi.com";
}
ApigatewayClient::ApigatewayClient(const Credential &credential, const string ®ion) :
ApigatewayClient(credential, region, ClientProfile())
{
}
ApigatewayClient::ApigatewayClient(const Credential &credential, const string ®ion, const ClientProfile &profile) :
AbstractClient(ENDPOINT, VERSION, credential, region, profile)
{
}
ApigatewayClient::AttachPluginOutcome ApigatewayClient::AttachPlugin(const AttachPluginRequest &request)
{
auto outcome = MakeRequest(request, "AttachPlugin");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
AttachPluginResponse rsp = AttachPluginResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return AttachPluginOutcome(rsp);
else
return AttachPluginOutcome(o.GetError());
}
else
{
return AttachPluginOutcome(outcome.GetError());
}
}
void ApigatewayClient::AttachPluginAsync(const AttachPluginRequest& request, const AttachPluginAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->AttachPlugin(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::AttachPluginOutcomeCallable ApigatewayClient::AttachPluginCallable(const AttachPluginRequest &request)
{
auto task = std::make_shared<std::packaged_task<AttachPluginOutcome()>>(
[this, request]()
{
return this->AttachPlugin(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::BindApiAppOutcome ApigatewayClient::BindApiApp(const BindApiAppRequest &request)
{
auto outcome = MakeRequest(request, "BindApiApp");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
BindApiAppResponse rsp = BindApiAppResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return BindApiAppOutcome(rsp);
else
return BindApiAppOutcome(o.GetError());
}
else
{
return BindApiAppOutcome(outcome.GetError());
}
}
void ApigatewayClient::BindApiAppAsync(const BindApiAppRequest& request, const BindApiAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->BindApiApp(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::BindApiAppOutcomeCallable ApigatewayClient::BindApiAppCallable(const BindApiAppRequest &request)
{
auto task = std::make_shared<std::packaged_task<BindApiAppOutcome()>>(
[this, request]()
{
return this->BindApiApp(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::BindEnvironmentOutcome ApigatewayClient::BindEnvironment(const BindEnvironmentRequest &request)
{
auto outcome = MakeRequest(request, "BindEnvironment");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
BindEnvironmentResponse rsp = BindEnvironmentResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return BindEnvironmentOutcome(rsp);
else
return BindEnvironmentOutcome(o.GetError());
}
else
{
return BindEnvironmentOutcome(outcome.GetError());
}
}
void ApigatewayClient::BindEnvironmentAsync(const BindEnvironmentRequest& request, const BindEnvironmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->BindEnvironment(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::BindEnvironmentOutcomeCallable ApigatewayClient::BindEnvironmentCallable(const BindEnvironmentRequest &request)
{
auto task = std::make_shared<std::packaged_task<BindEnvironmentOutcome()>>(
[this, request]()
{
return this->BindEnvironment(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::BindIPStrategyOutcome ApigatewayClient::BindIPStrategy(const BindIPStrategyRequest &request)
{
auto outcome = MakeRequest(request, "BindIPStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
BindIPStrategyResponse rsp = BindIPStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return BindIPStrategyOutcome(rsp);
else
return BindIPStrategyOutcome(o.GetError());
}
else
{
return BindIPStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::BindIPStrategyAsync(const BindIPStrategyRequest& request, const BindIPStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->BindIPStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::BindIPStrategyOutcomeCallable ApigatewayClient::BindIPStrategyCallable(const BindIPStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<BindIPStrategyOutcome()>>(
[this, request]()
{
return this->BindIPStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::BindSecretIdsOutcome ApigatewayClient::BindSecretIds(const BindSecretIdsRequest &request)
{
auto outcome = MakeRequest(request, "BindSecretIds");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
BindSecretIdsResponse rsp = BindSecretIdsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return BindSecretIdsOutcome(rsp);
else
return BindSecretIdsOutcome(o.GetError());
}
else
{
return BindSecretIdsOutcome(outcome.GetError());
}
}
void ApigatewayClient::BindSecretIdsAsync(const BindSecretIdsRequest& request, const BindSecretIdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->BindSecretIds(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::BindSecretIdsOutcomeCallable ApigatewayClient::BindSecretIdsCallable(const BindSecretIdsRequest &request)
{
auto task = std::make_shared<std::packaged_task<BindSecretIdsOutcome()>>(
[this, request]()
{
return this->BindSecretIds(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::BindSubDomainOutcome ApigatewayClient::BindSubDomain(const BindSubDomainRequest &request)
{
auto outcome = MakeRequest(request, "BindSubDomain");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
BindSubDomainResponse rsp = BindSubDomainResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return BindSubDomainOutcome(rsp);
else
return BindSubDomainOutcome(o.GetError());
}
else
{
return BindSubDomainOutcome(outcome.GetError());
}
}
void ApigatewayClient::BindSubDomainAsync(const BindSubDomainRequest& request, const BindSubDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->BindSubDomain(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::BindSubDomainOutcomeCallable ApigatewayClient::BindSubDomainCallable(const BindSubDomainRequest &request)
{
auto task = std::make_shared<std::packaged_task<BindSubDomainOutcome()>>(
[this, request]()
{
return this->BindSubDomain(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::BuildAPIDocOutcome ApigatewayClient::BuildAPIDoc(const BuildAPIDocRequest &request)
{
auto outcome = MakeRequest(request, "BuildAPIDoc");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
BuildAPIDocResponse rsp = BuildAPIDocResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return BuildAPIDocOutcome(rsp);
else
return BuildAPIDocOutcome(o.GetError());
}
else
{
return BuildAPIDocOutcome(outcome.GetError());
}
}
void ApigatewayClient::BuildAPIDocAsync(const BuildAPIDocRequest& request, const BuildAPIDocAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->BuildAPIDoc(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::BuildAPIDocOutcomeCallable ApigatewayClient::BuildAPIDocCallable(const BuildAPIDocRequest &request)
{
auto task = std::make_shared<std::packaged_task<BuildAPIDocOutcome()>>(
[this, request]()
{
return this->BuildAPIDoc(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::CreateAPIDocOutcome ApigatewayClient::CreateAPIDoc(const CreateAPIDocRequest &request)
{
auto outcome = MakeRequest(request, "CreateAPIDoc");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CreateAPIDocResponse rsp = CreateAPIDocResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CreateAPIDocOutcome(rsp);
else
return CreateAPIDocOutcome(o.GetError());
}
else
{
return CreateAPIDocOutcome(outcome.GetError());
}
}
void ApigatewayClient::CreateAPIDocAsync(const CreateAPIDocRequest& request, const CreateAPIDocAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CreateAPIDoc(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::CreateAPIDocOutcomeCallable ApigatewayClient::CreateAPIDocCallable(const CreateAPIDocRequest &request)
{
auto task = std::make_shared<std::packaged_task<CreateAPIDocOutcome()>>(
[this, request]()
{
return this->CreateAPIDoc(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::CreateApiOutcome ApigatewayClient::CreateApi(const CreateApiRequest &request)
{
auto outcome = MakeRequest(request, "CreateApi");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CreateApiResponse rsp = CreateApiResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CreateApiOutcome(rsp);
else
return CreateApiOutcome(o.GetError());
}
else
{
return CreateApiOutcome(outcome.GetError());
}
}
void ApigatewayClient::CreateApiAsync(const CreateApiRequest& request, const CreateApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CreateApi(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::CreateApiOutcomeCallable ApigatewayClient::CreateApiCallable(const CreateApiRequest &request)
{
auto task = std::make_shared<std::packaged_task<CreateApiOutcome()>>(
[this, request]()
{
return this->CreateApi(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::CreateApiAppOutcome ApigatewayClient::CreateApiApp(const CreateApiAppRequest &request)
{
auto outcome = MakeRequest(request, "CreateApiApp");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CreateApiAppResponse rsp = CreateApiAppResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CreateApiAppOutcome(rsp);
else
return CreateApiAppOutcome(o.GetError());
}
else
{
return CreateApiAppOutcome(outcome.GetError());
}
}
void ApigatewayClient::CreateApiAppAsync(const CreateApiAppRequest& request, const CreateApiAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CreateApiApp(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::CreateApiAppOutcomeCallable ApigatewayClient::CreateApiAppCallable(const CreateApiAppRequest &request)
{
auto task = std::make_shared<std::packaged_task<CreateApiAppOutcome()>>(
[this, request]()
{
return this->CreateApiApp(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::CreateApiKeyOutcome ApigatewayClient::CreateApiKey(const CreateApiKeyRequest &request)
{
auto outcome = MakeRequest(request, "CreateApiKey");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CreateApiKeyResponse rsp = CreateApiKeyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CreateApiKeyOutcome(rsp);
else
return CreateApiKeyOutcome(o.GetError());
}
else
{
return CreateApiKeyOutcome(outcome.GetError());
}
}
void ApigatewayClient::CreateApiKeyAsync(const CreateApiKeyRequest& request, const CreateApiKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CreateApiKey(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::CreateApiKeyOutcomeCallable ApigatewayClient::CreateApiKeyCallable(const CreateApiKeyRequest &request)
{
auto task = std::make_shared<std::packaged_task<CreateApiKeyOutcome()>>(
[this, request]()
{
return this->CreateApiKey(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::CreateIPStrategyOutcome ApigatewayClient::CreateIPStrategy(const CreateIPStrategyRequest &request)
{
auto outcome = MakeRequest(request, "CreateIPStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CreateIPStrategyResponse rsp = CreateIPStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CreateIPStrategyOutcome(rsp);
else
return CreateIPStrategyOutcome(o.GetError());
}
else
{
return CreateIPStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::CreateIPStrategyAsync(const CreateIPStrategyRequest& request, const CreateIPStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CreateIPStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::CreateIPStrategyOutcomeCallable ApigatewayClient::CreateIPStrategyCallable(const CreateIPStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<CreateIPStrategyOutcome()>>(
[this, request]()
{
return this->CreateIPStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::CreatePluginOutcome ApigatewayClient::CreatePlugin(const CreatePluginRequest &request)
{
auto outcome = MakeRequest(request, "CreatePlugin");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CreatePluginResponse rsp = CreatePluginResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CreatePluginOutcome(rsp);
else
return CreatePluginOutcome(o.GetError());
}
else
{
return CreatePluginOutcome(outcome.GetError());
}
}
void ApigatewayClient::CreatePluginAsync(const CreatePluginRequest& request, const CreatePluginAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CreatePlugin(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::CreatePluginOutcomeCallable ApigatewayClient::CreatePluginCallable(const CreatePluginRequest &request)
{
auto task = std::make_shared<std::packaged_task<CreatePluginOutcome()>>(
[this, request]()
{
return this->CreatePlugin(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::CreateServiceOutcome ApigatewayClient::CreateService(const CreateServiceRequest &request)
{
auto outcome = MakeRequest(request, "CreateService");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CreateServiceResponse rsp = CreateServiceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CreateServiceOutcome(rsp);
else
return CreateServiceOutcome(o.GetError());
}
else
{
return CreateServiceOutcome(outcome.GetError());
}
}
void ApigatewayClient::CreateServiceAsync(const CreateServiceRequest& request, const CreateServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CreateService(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::CreateServiceOutcomeCallable ApigatewayClient::CreateServiceCallable(const CreateServiceRequest &request)
{
auto task = std::make_shared<std::packaged_task<CreateServiceOutcome()>>(
[this, request]()
{
return this->CreateService(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::CreateUpstreamOutcome ApigatewayClient::CreateUpstream(const CreateUpstreamRequest &request)
{
auto outcome = MakeRequest(request, "CreateUpstream");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CreateUpstreamResponse rsp = CreateUpstreamResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CreateUpstreamOutcome(rsp);
else
return CreateUpstreamOutcome(o.GetError());
}
else
{
return CreateUpstreamOutcome(outcome.GetError());
}
}
void ApigatewayClient::CreateUpstreamAsync(const CreateUpstreamRequest& request, const CreateUpstreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CreateUpstream(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::CreateUpstreamOutcomeCallable ApigatewayClient::CreateUpstreamCallable(const CreateUpstreamRequest &request)
{
auto task = std::make_shared<std::packaged_task<CreateUpstreamOutcome()>>(
[this, request]()
{
return this->CreateUpstream(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::CreateUsagePlanOutcome ApigatewayClient::CreateUsagePlan(const CreateUsagePlanRequest &request)
{
auto outcome = MakeRequest(request, "CreateUsagePlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
CreateUsagePlanResponse rsp = CreateUsagePlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return CreateUsagePlanOutcome(rsp);
else
return CreateUsagePlanOutcome(o.GetError());
}
else
{
return CreateUsagePlanOutcome(outcome.GetError());
}
}
void ApigatewayClient::CreateUsagePlanAsync(const CreateUsagePlanRequest& request, const CreateUsagePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->CreateUsagePlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::CreateUsagePlanOutcomeCallable ApigatewayClient::CreateUsagePlanCallable(const CreateUsagePlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<CreateUsagePlanOutcome()>>(
[this, request]()
{
return this->CreateUsagePlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeleteAPIDocOutcome ApigatewayClient::DeleteAPIDoc(const DeleteAPIDocRequest &request)
{
auto outcome = MakeRequest(request, "DeleteAPIDoc");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteAPIDocResponse rsp = DeleteAPIDocResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteAPIDocOutcome(rsp);
else
return DeleteAPIDocOutcome(o.GetError());
}
else
{
return DeleteAPIDocOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeleteAPIDocAsync(const DeleteAPIDocRequest& request, const DeleteAPIDocAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteAPIDoc(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeleteAPIDocOutcomeCallable ApigatewayClient::DeleteAPIDocCallable(const DeleteAPIDocRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteAPIDocOutcome()>>(
[this, request]()
{
return this->DeleteAPIDoc(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeleteApiOutcome ApigatewayClient::DeleteApi(const DeleteApiRequest &request)
{
auto outcome = MakeRequest(request, "DeleteApi");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteApiResponse rsp = DeleteApiResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteApiOutcome(rsp);
else
return DeleteApiOutcome(o.GetError());
}
else
{
return DeleteApiOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeleteApiAsync(const DeleteApiRequest& request, const DeleteApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteApi(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeleteApiOutcomeCallable ApigatewayClient::DeleteApiCallable(const DeleteApiRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteApiOutcome()>>(
[this, request]()
{
return this->DeleteApi(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeleteApiAppOutcome ApigatewayClient::DeleteApiApp(const DeleteApiAppRequest &request)
{
auto outcome = MakeRequest(request, "DeleteApiApp");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteApiAppResponse rsp = DeleteApiAppResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteApiAppOutcome(rsp);
else
return DeleteApiAppOutcome(o.GetError());
}
else
{
return DeleteApiAppOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeleteApiAppAsync(const DeleteApiAppRequest& request, const DeleteApiAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteApiApp(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeleteApiAppOutcomeCallable ApigatewayClient::DeleteApiAppCallable(const DeleteApiAppRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteApiAppOutcome()>>(
[this, request]()
{
return this->DeleteApiApp(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeleteApiKeyOutcome ApigatewayClient::DeleteApiKey(const DeleteApiKeyRequest &request)
{
auto outcome = MakeRequest(request, "DeleteApiKey");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteApiKeyResponse rsp = DeleteApiKeyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteApiKeyOutcome(rsp);
else
return DeleteApiKeyOutcome(o.GetError());
}
else
{
return DeleteApiKeyOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeleteApiKeyAsync(const DeleteApiKeyRequest& request, const DeleteApiKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteApiKey(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeleteApiKeyOutcomeCallable ApigatewayClient::DeleteApiKeyCallable(const DeleteApiKeyRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteApiKeyOutcome()>>(
[this, request]()
{
return this->DeleteApiKey(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeleteIPStrategyOutcome ApigatewayClient::DeleteIPStrategy(const DeleteIPStrategyRequest &request)
{
auto outcome = MakeRequest(request, "DeleteIPStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteIPStrategyResponse rsp = DeleteIPStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteIPStrategyOutcome(rsp);
else
return DeleteIPStrategyOutcome(o.GetError());
}
else
{
return DeleteIPStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeleteIPStrategyAsync(const DeleteIPStrategyRequest& request, const DeleteIPStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteIPStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeleteIPStrategyOutcomeCallable ApigatewayClient::DeleteIPStrategyCallable(const DeleteIPStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteIPStrategyOutcome()>>(
[this, request]()
{
return this->DeleteIPStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeletePluginOutcome ApigatewayClient::DeletePlugin(const DeletePluginRequest &request)
{
auto outcome = MakeRequest(request, "DeletePlugin");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeletePluginResponse rsp = DeletePluginResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeletePluginOutcome(rsp);
else
return DeletePluginOutcome(o.GetError());
}
else
{
return DeletePluginOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeletePluginAsync(const DeletePluginRequest& request, const DeletePluginAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeletePlugin(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeletePluginOutcomeCallable ApigatewayClient::DeletePluginCallable(const DeletePluginRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeletePluginOutcome()>>(
[this, request]()
{
return this->DeletePlugin(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeleteServiceOutcome ApigatewayClient::DeleteService(const DeleteServiceRequest &request)
{
auto outcome = MakeRequest(request, "DeleteService");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteServiceResponse rsp = DeleteServiceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteServiceOutcome(rsp);
else
return DeleteServiceOutcome(o.GetError());
}
else
{
return DeleteServiceOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeleteServiceAsync(const DeleteServiceRequest& request, const DeleteServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteService(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeleteServiceOutcomeCallable ApigatewayClient::DeleteServiceCallable(const DeleteServiceRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteServiceOutcome()>>(
[this, request]()
{
return this->DeleteService(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeleteServiceSubDomainMappingOutcome ApigatewayClient::DeleteServiceSubDomainMapping(const DeleteServiceSubDomainMappingRequest &request)
{
auto outcome = MakeRequest(request, "DeleteServiceSubDomainMapping");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteServiceSubDomainMappingResponse rsp = DeleteServiceSubDomainMappingResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteServiceSubDomainMappingOutcome(rsp);
else
return DeleteServiceSubDomainMappingOutcome(o.GetError());
}
else
{
return DeleteServiceSubDomainMappingOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeleteServiceSubDomainMappingAsync(const DeleteServiceSubDomainMappingRequest& request, const DeleteServiceSubDomainMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteServiceSubDomainMapping(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeleteServiceSubDomainMappingOutcomeCallable ApigatewayClient::DeleteServiceSubDomainMappingCallable(const DeleteServiceSubDomainMappingRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteServiceSubDomainMappingOutcome()>>(
[this, request]()
{
return this->DeleteServiceSubDomainMapping(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeleteUpstreamOutcome ApigatewayClient::DeleteUpstream(const DeleteUpstreamRequest &request)
{
auto outcome = MakeRequest(request, "DeleteUpstream");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteUpstreamResponse rsp = DeleteUpstreamResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteUpstreamOutcome(rsp);
else
return DeleteUpstreamOutcome(o.GetError());
}
else
{
return DeleteUpstreamOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeleteUpstreamAsync(const DeleteUpstreamRequest& request, const DeleteUpstreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteUpstream(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeleteUpstreamOutcomeCallable ApigatewayClient::DeleteUpstreamCallable(const DeleteUpstreamRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteUpstreamOutcome()>>(
[this, request]()
{
return this->DeleteUpstream(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DeleteUsagePlanOutcome ApigatewayClient::DeleteUsagePlan(const DeleteUsagePlanRequest &request)
{
auto outcome = MakeRequest(request, "DeleteUsagePlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DeleteUsagePlanResponse rsp = DeleteUsagePlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DeleteUsagePlanOutcome(rsp);
else
return DeleteUsagePlanOutcome(o.GetError());
}
else
{
return DeleteUsagePlanOutcome(outcome.GetError());
}
}
void ApigatewayClient::DeleteUsagePlanAsync(const DeleteUsagePlanRequest& request, const DeleteUsagePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DeleteUsagePlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DeleteUsagePlanOutcomeCallable ApigatewayClient::DeleteUsagePlanCallable(const DeleteUsagePlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<DeleteUsagePlanOutcome()>>(
[this, request]()
{
return this->DeleteUsagePlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DemoteServiceUsagePlanOutcome ApigatewayClient::DemoteServiceUsagePlan(const DemoteServiceUsagePlanRequest &request)
{
auto outcome = MakeRequest(request, "DemoteServiceUsagePlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DemoteServiceUsagePlanResponse rsp = DemoteServiceUsagePlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DemoteServiceUsagePlanOutcome(rsp);
else
return DemoteServiceUsagePlanOutcome(o.GetError());
}
else
{
return DemoteServiceUsagePlanOutcome(outcome.GetError());
}
}
void ApigatewayClient::DemoteServiceUsagePlanAsync(const DemoteServiceUsagePlanRequest& request, const DemoteServiceUsagePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DemoteServiceUsagePlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DemoteServiceUsagePlanOutcomeCallable ApigatewayClient::DemoteServiceUsagePlanCallable(const DemoteServiceUsagePlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<DemoteServiceUsagePlanOutcome()>>(
[this, request]()
{
return this->DemoteServiceUsagePlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeAPIDocDetailOutcome ApigatewayClient::DescribeAPIDocDetail(const DescribeAPIDocDetailRequest &request)
{
auto outcome = MakeRequest(request, "DescribeAPIDocDetail");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeAPIDocDetailResponse rsp = DescribeAPIDocDetailResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeAPIDocDetailOutcome(rsp);
else
return DescribeAPIDocDetailOutcome(o.GetError());
}
else
{
return DescribeAPIDocDetailOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeAPIDocDetailAsync(const DescribeAPIDocDetailRequest& request, const DescribeAPIDocDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeAPIDocDetail(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeAPIDocDetailOutcomeCallable ApigatewayClient::DescribeAPIDocDetailCallable(const DescribeAPIDocDetailRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeAPIDocDetailOutcome()>>(
[this, request]()
{
return this->DescribeAPIDocDetail(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeAPIDocsOutcome ApigatewayClient::DescribeAPIDocs(const DescribeAPIDocsRequest &request)
{
auto outcome = MakeRequest(request, "DescribeAPIDocs");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeAPIDocsResponse rsp = DescribeAPIDocsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeAPIDocsOutcome(rsp);
else
return DescribeAPIDocsOutcome(o.GetError());
}
else
{
return DescribeAPIDocsOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeAPIDocsAsync(const DescribeAPIDocsRequest& request, const DescribeAPIDocsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeAPIDocs(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeAPIDocsOutcomeCallable ApigatewayClient::DescribeAPIDocsCallable(const DescribeAPIDocsRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeAPIDocsOutcome()>>(
[this, request]()
{
return this->DescribeAPIDocs(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeAllPluginApisOutcome ApigatewayClient::DescribeAllPluginApis(const DescribeAllPluginApisRequest &request)
{
auto outcome = MakeRequest(request, "DescribeAllPluginApis");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeAllPluginApisResponse rsp = DescribeAllPluginApisResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeAllPluginApisOutcome(rsp);
else
return DescribeAllPluginApisOutcome(o.GetError());
}
else
{
return DescribeAllPluginApisOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeAllPluginApisAsync(const DescribeAllPluginApisRequest& request, const DescribeAllPluginApisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeAllPluginApis(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeAllPluginApisOutcomeCallable ApigatewayClient::DescribeAllPluginApisCallable(const DescribeAllPluginApisRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeAllPluginApisOutcome()>>(
[this, request]()
{
return this->DescribeAllPluginApis(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiOutcome ApigatewayClient::DescribeApi(const DescribeApiRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApi");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiResponse rsp = DescribeApiResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiOutcome(rsp);
else
return DescribeApiOutcome(o.GetError());
}
else
{
return DescribeApiOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiAsync(const DescribeApiRequest& request, const DescribeApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApi(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiOutcomeCallable ApigatewayClient::DescribeApiCallable(const DescribeApiRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiOutcome()>>(
[this, request]()
{
return this->DescribeApi(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiAppOutcome ApigatewayClient::DescribeApiApp(const DescribeApiAppRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApiApp");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiAppResponse rsp = DescribeApiAppResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiAppOutcome(rsp);
else
return DescribeApiAppOutcome(o.GetError());
}
else
{
return DescribeApiAppOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiAppAsync(const DescribeApiAppRequest& request, const DescribeApiAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApiApp(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiAppOutcomeCallable ApigatewayClient::DescribeApiAppCallable(const DescribeApiAppRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiAppOutcome()>>(
[this, request]()
{
return this->DescribeApiApp(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiAppBindApisStatusOutcome ApigatewayClient::DescribeApiAppBindApisStatus(const DescribeApiAppBindApisStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApiAppBindApisStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiAppBindApisStatusResponse rsp = DescribeApiAppBindApisStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiAppBindApisStatusOutcome(rsp);
else
return DescribeApiAppBindApisStatusOutcome(o.GetError());
}
else
{
return DescribeApiAppBindApisStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiAppBindApisStatusAsync(const DescribeApiAppBindApisStatusRequest& request, const DescribeApiAppBindApisStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApiAppBindApisStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiAppBindApisStatusOutcomeCallable ApigatewayClient::DescribeApiAppBindApisStatusCallable(const DescribeApiAppBindApisStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiAppBindApisStatusOutcome()>>(
[this, request]()
{
return this->DescribeApiAppBindApisStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiAppsStatusOutcome ApigatewayClient::DescribeApiAppsStatus(const DescribeApiAppsStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApiAppsStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiAppsStatusResponse rsp = DescribeApiAppsStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiAppsStatusOutcome(rsp);
else
return DescribeApiAppsStatusOutcome(o.GetError());
}
else
{
return DescribeApiAppsStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiAppsStatusAsync(const DescribeApiAppsStatusRequest& request, const DescribeApiAppsStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApiAppsStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiAppsStatusOutcomeCallable ApigatewayClient::DescribeApiAppsStatusCallable(const DescribeApiAppsStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiAppsStatusOutcome()>>(
[this, request]()
{
return this->DescribeApiAppsStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiBindApiAppsStatusOutcome ApigatewayClient::DescribeApiBindApiAppsStatus(const DescribeApiBindApiAppsStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApiBindApiAppsStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiBindApiAppsStatusResponse rsp = DescribeApiBindApiAppsStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiBindApiAppsStatusOutcome(rsp);
else
return DescribeApiBindApiAppsStatusOutcome(o.GetError());
}
else
{
return DescribeApiBindApiAppsStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiBindApiAppsStatusAsync(const DescribeApiBindApiAppsStatusRequest& request, const DescribeApiBindApiAppsStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApiBindApiAppsStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiBindApiAppsStatusOutcomeCallable ApigatewayClient::DescribeApiBindApiAppsStatusCallable(const DescribeApiBindApiAppsStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiBindApiAppsStatusOutcome()>>(
[this, request]()
{
return this->DescribeApiBindApiAppsStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiEnvironmentStrategyOutcome ApigatewayClient::DescribeApiEnvironmentStrategy(const DescribeApiEnvironmentStrategyRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApiEnvironmentStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiEnvironmentStrategyResponse rsp = DescribeApiEnvironmentStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiEnvironmentStrategyOutcome(rsp);
else
return DescribeApiEnvironmentStrategyOutcome(o.GetError());
}
else
{
return DescribeApiEnvironmentStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiEnvironmentStrategyAsync(const DescribeApiEnvironmentStrategyRequest& request, const DescribeApiEnvironmentStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApiEnvironmentStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiEnvironmentStrategyOutcomeCallable ApigatewayClient::DescribeApiEnvironmentStrategyCallable(const DescribeApiEnvironmentStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiEnvironmentStrategyOutcome()>>(
[this, request]()
{
return this->DescribeApiEnvironmentStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiForApiAppOutcome ApigatewayClient::DescribeApiForApiApp(const DescribeApiForApiAppRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApiForApiApp");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiForApiAppResponse rsp = DescribeApiForApiAppResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiForApiAppOutcome(rsp);
else
return DescribeApiForApiAppOutcome(o.GetError());
}
else
{
return DescribeApiForApiAppOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiForApiAppAsync(const DescribeApiForApiAppRequest& request, const DescribeApiForApiAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApiForApiApp(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiForApiAppOutcomeCallable ApigatewayClient::DescribeApiForApiAppCallable(const DescribeApiForApiAppRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiForApiAppOutcome()>>(
[this, request]()
{
return this->DescribeApiForApiApp(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiKeyOutcome ApigatewayClient::DescribeApiKey(const DescribeApiKeyRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApiKey");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiKeyResponse rsp = DescribeApiKeyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiKeyOutcome(rsp);
else
return DescribeApiKeyOutcome(o.GetError());
}
else
{
return DescribeApiKeyOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiKeyAsync(const DescribeApiKeyRequest& request, const DescribeApiKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApiKey(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiKeyOutcomeCallable ApigatewayClient::DescribeApiKeyCallable(const DescribeApiKeyRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiKeyOutcome()>>(
[this, request]()
{
return this->DescribeApiKey(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiKeysStatusOutcome ApigatewayClient::DescribeApiKeysStatus(const DescribeApiKeysStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApiKeysStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiKeysStatusResponse rsp = DescribeApiKeysStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiKeysStatusOutcome(rsp);
else
return DescribeApiKeysStatusOutcome(o.GetError());
}
else
{
return DescribeApiKeysStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiKeysStatusAsync(const DescribeApiKeysStatusRequest& request, const DescribeApiKeysStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApiKeysStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiKeysStatusOutcomeCallable ApigatewayClient::DescribeApiKeysStatusCallable(const DescribeApiKeysStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiKeysStatusOutcome()>>(
[this, request]()
{
return this->DescribeApiKeysStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApiUsagePlanOutcome ApigatewayClient::DescribeApiUsagePlan(const DescribeApiUsagePlanRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApiUsagePlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApiUsagePlanResponse rsp = DescribeApiUsagePlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApiUsagePlanOutcome(rsp);
else
return DescribeApiUsagePlanOutcome(o.GetError());
}
else
{
return DescribeApiUsagePlanOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApiUsagePlanAsync(const DescribeApiUsagePlanRequest& request, const DescribeApiUsagePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApiUsagePlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApiUsagePlanOutcomeCallable ApigatewayClient::DescribeApiUsagePlanCallable(const DescribeApiUsagePlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApiUsagePlanOutcome()>>(
[this, request]()
{
return this->DescribeApiUsagePlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeApisStatusOutcome ApigatewayClient::DescribeApisStatus(const DescribeApisStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeApisStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeApisStatusResponse rsp = DescribeApisStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeApisStatusOutcome(rsp);
else
return DescribeApisStatusOutcome(o.GetError());
}
else
{
return DescribeApisStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeApisStatusAsync(const DescribeApisStatusRequest& request, const DescribeApisStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeApisStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeApisStatusOutcomeCallable ApigatewayClient::DescribeApisStatusCallable(const DescribeApisStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeApisStatusOutcome()>>(
[this, request]()
{
return this->DescribeApisStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeExclusiveInstanceDetailOutcome ApigatewayClient::DescribeExclusiveInstanceDetail(const DescribeExclusiveInstanceDetailRequest &request)
{
auto outcome = MakeRequest(request, "DescribeExclusiveInstanceDetail");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeExclusiveInstanceDetailResponse rsp = DescribeExclusiveInstanceDetailResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeExclusiveInstanceDetailOutcome(rsp);
else
return DescribeExclusiveInstanceDetailOutcome(o.GetError());
}
else
{
return DescribeExclusiveInstanceDetailOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeExclusiveInstanceDetailAsync(const DescribeExclusiveInstanceDetailRequest& request, const DescribeExclusiveInstanceDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeExclusiveInstanceDetail(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeExclusiveInstanceDetailOutcomeCallable ApigatewayClient::DescribeExclusiveInstanceDetailCallable(const DescribeExclusiveInstanceDetailRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeExclusiveInstanceDetailOutcome()>>(
[this, request]()
{
return this->DescribeExclusiveInstanceDetail(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeExclusiveInstancesOutcome ApigatewayClient::DescribeExclusiveInstances(const DescribeExclusiveInstancesRequest &request)
{
auto outcome = MakeRequest(request, "DescribeExclusiveInstances");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeExclusiveInstancesResponse rsp = DescribeExclusiveInstancesResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeExclusiveInstancesOutcome(rsp);
else
return DescribeExclusiveInstancesOutcome(o.GetError());
}
else
{
return DescribeExclusiveInstancesOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeExclusiveInstancesAsync(const DescribeExclusiveInstancesRequest& request, const DescribeExclusiveInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeExclusiveInstances(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeExclusiveInstancesOutcomeCallable ApigatewayClient::DescribeExclusiveInstancesCallable(const DescribeExclusiveInstancesRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeExclusiveInstancesOutcome()>>(
[this, request]()
{
return this->DescribeExclusiveInstances(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeExclusiveInstancesStatusOutcome ApigatewayClient::DescribeExclusiveInstancesStatus(const DescribeExclusiveInstancesStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeExclusiveInstancesStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeExclusiveInstancesStatusResponse rsp = DescribeExclusiveInstancesStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeExclusiveInstancesStatusOutcome(rsp);
else
return DescribeExclusiveInstancesStatusOutcome(o.GetError());
}
else
{
return DescribeExclusiveInstancesStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeExclusiveInstancesStatusAsync(const DescribeExclusiveInstancesStatusRequest& request, const DescribeExclusiveInstancesStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeExclusiveInstancesStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeExclusiveInstancesStatusOutcomeCallable ApigatewayClient::DescribeExclusiveInstancesStatusCallable(const DescribeExclusiveInstancesStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeExclusiveInstancesStatusOutcome()>>(
[this, request]()
{
return this->DescribeExclusiveInstancesStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeIPStrategyOutcome ApigatewayClient::DescribeIPStrategy(const DescribeIPStrategyRequest &request)
{
auto outcome = MakeRequest(request, "DescribeIPStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeIPStrategyResponse rsp = DescribeIPStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeIPStrategyOutcome(rsp);
else
return DescribeIPStrategyOutcome(o.GetError());
}
else
{
return DescribeIPStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeIPStrategyAsync(const DescribeIPStrategyRequest& request, const DescribeIPStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeIPStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeIPStrategyOutcomeCallable ApigatewayClient::DescribeIPStrategyCallable(const DescribeIPStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeIPStrategyOutcome()>>(
[this, request]()
{
return this->DescribeIPStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeIPStrategyApisStatusOutcome ApigatewayClient::DescribeIPStrategyApisStatus(const DescribeIPStrategyApisStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeIPStrategyApisStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeIPStrategyApisStatusResponse rsp = DescribeIPStrategyApisStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeIPStrategyApisStatusOutcome(rsp);
else
return DescribeIPStrategyApisStatusOutcome(o.GetError());
}
else
{
return DescribeIPStrategyApisStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeIPStrategyApisStatusAsync(const DescribeIPStrategyApisStatusRequest& request, const DescribeIPStrategyApisStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeIPStrategyApisStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeIPStrategyApisStatusOutcomeCallable ApigatewayClient::DescribeIPStrategyApisStatusCallable(const DescribeIPStrategyApisStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeIPStrategyApisStatusOutcome()>>(
[this, request]()
{
return this->DescribeIPStrategyApisStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeIPStrategysStatusOutcome ApigatewayClient::DescribeIPStrategysStatus(const DescribeIPStrategysStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeIPStrategysStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeIPStrategysStatusResponse rsp = DescribeIPStrategysStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeIPStrategysStatusOutcome(rsp);
else
return DescribeIPStrategysStatusOutcome(o.GetError());
}
else
{
return DescribeIPStrategysStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeIPStrategysStatusAsync(const DescribeIPStrategysStatusRequest& request, const DescribeIPStrategysStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeIPStrategysStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeIPStrategysStatusOutcomeCallable ApigatewayClient::DescribeIPStrategysStatusCallable(const DescribeIPStrategysStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeIPStrategysStatusOutcome()>>(
[this, request]()
{
return this->DescribeIPStrategysStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeLogSearchOutcome ApigatewayClient::DescribeLogSearch(const DescribeLogSearchRequest &request)
{
auto outcome = MakeRequest(request, "DescribeLogSearch");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeLogSearchResponse rsp = DescribeLogSearchResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeLogSearchOutcome(rsp);
else
return DescribeLogSearchOutcome(o.GetError());
}
else
{
return DescribeLogSearchOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeLogSearchAsync(const DescribeLogSearchRequest& request, const DescribeLogSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeLogSearch(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeLogSearchOutcomeCallable ApigatewayClient::DescribeLogSearchCallable(const DescribeLogSearchRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeLogSearchOutcome()>>(
[this, request]()
{
return this->DescribeLogSearch(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribePluginOutcome ApigatewayClient::DescribePlugin(const DescribePluginRequest &request)
{
auto outcome = MakeRequest(request, "DescribePlugin");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribePluginResponse rsp = DescribePluginResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribePluginOutcome(rsp);
else
return DescribePluginOutcome(o.GetError());
}
else
{
return DescribePluginOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribePluginAsync(const DescribePluginRequest& request, const DescribePluginAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribePlugin(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribePluginOutcomeCallable ApigatewayClient::DescribePluginCallable(const DescribePluginRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribePluginOutcome()>>(
[this, request]()
{
return this->DescribePlugin(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribePluginApisOutcome ApigatewayClient::DescribePluginApis(const DescribePluginApisRequest &request)
{
auto outcome = MakeRequest(request, "DescribePluginApis");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribePluginApisResponse rsp = DescribePluginApisResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribePluginApisOutcome(rsp);
else
return DescribePluginApisOutcome(o.GetError());
}
else
{
return DescribePluginApisOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribePluginApisAsync(const DescribePluginApisRequest& request, const DescribePluginApisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribePluginApis(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribePluginApisOutcomeCallable ApigatewayClient::DescribePluginApisCallable(const DescribePluginApisRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribePluginApisOutcome()>>(
[this, request]()
{
return this->DescribePluginApis(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribePluginsOutcome ApigatewayClient::DescribePlugins(const DescribePluginsRequest &request)
{
auto outcome = MakeRequest(request, "DescribePlugins");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribePluginsResponse rsp = DescribePluginsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribePluginsOutcome(rsp);
else
return DescribePluginsOutcome(o.GetError());
}
else
{
return DescribePluginsOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribePluginsAsync(const DescribePluginsRequest& request, const DescribePluginsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribePlugins(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribePluginsOutcomeCallable ApigatewayClient::DescribePluginsCallable(const DescribePluginsRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribePluginsOutcome()>>(
[this, request]()
{
return this->DescribePlugins(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribePluginsByApiOutcome ApigatewayClient::DescribePluginsByApi(const DescribePluginsByApiRequest &request)
{
auto outcome = MakeRequest(request, "DescribePluginsByApi");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribePluginsByApiResponse rsp = DescribePluginsByApiResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribePluginsByApiOutcome(rsp);
else
return DescribePluginsByApiOutcome(o.GetError());
}
else
{
return DescribePluginsByApiOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribePluginsByApiAsync(const DescribePluginsByApiRequest& request, const DescribePluginsByApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribePluginsByApi(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribePluginsByApiOutcomeCallable ApigatewayClient::DescribePluginsByApiCallable(const DescribePluginsByApiRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribePluginsByApiOutcome()>>(
[this, request]()
{
return this->DescribePluginsByApi(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServiceOutcome ApigatewayClient::DescribeService(const DescribeServiceRequest &request)
{
auto outcome = MakeRequest(request, "DescribeService");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServiceResponse rsp = DescribeServiceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServiceOutcome(rsp);
else
return DescribeServiceOutcome(o.GetError());
}
else
{
return DescribeServiceOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServiceAsync(const DescribeServiceRequest& request, const DescribeServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeService(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServiceOutcomeCallable ApigatewayClient::DescribeServiceCallable(const DescribeServiceRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServiceOutcome()>>(
[this, request]()
{
return this->DescribeService(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServiceEnvironmentListOutcome ApigatewayClient::DescribeServiceEnvironmentList(const DescribeServiceEnvironmentListRequest &request)
{
auto outcome = MakeRequest(request, "DescribeServiceEnvironmentList");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServiceEnvironmentListResponse rsp = DescribeServiceEnvironmentListResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServiceEnvironmentListOutcome(rsp);
else
return DescribeServiceEnvironmentListOutcome(o.GetError());
}
else
{
return DescribeServiceEnvironmentListOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServiceEnvironmentListAsync(const DescribeServiceEnvironmentListRequest& request, const DescribeServiceEnvironmentListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeServiceEnvironmentList(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServiceEnvironmentListOutcomeCallable ApigatewayClient::DescribeServiceEnvironmentListCallable(const DescribeServiceEnvironmentListRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServiceEnvironmentListOutcome()>>(
[this, request]()
{
return this->DescribeServiceEnvironmentList(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServiceEnvironmentReleaseHistoryOutcome ApigatewayClient::DescribeServiceEnvironmentReleaseHistory(const DescribeServiceEnvironmentReleaseHistoryRequest &request)
{
auto outcome = MakeRequest(request, "DescribeServiceEnvironmentReleaseHistory");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServiceEnvironmentReleaseHistoryResponse rsp = DescribeServiceEnvironmentReleaseHistoryResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServiceEnvironmentReleaseHistoryOutcome(rsp);
else
return DescribeServiceEnvironmentReleaseHistoryOutcome(o.GetError());
}
else
{
return DescribeServiceEnvironmentReleaseHistoryOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServiceEnvironmentReleaseHistoryAsync(const DescribeServiceEnvironmentReleaseHistoryRequest& request, const DescribeServiceEnvironmentReleaseHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeServiceEnvironmentReleaseHistory(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServiceEnvironmentReleaseHistoryOutcomeCallable ApigatewayClient::DescribeServiceEnvironmentReleaseHistoryCallable(const DescribeServiceEnvironmentReleaseHistoryRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServiceEnvironmentReleaseHistoryOutcome()>>(
[this, request]()
{
return this->DescribeServiceEnvironmentReleaseHistory(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServiceEnvironmentStrategyOutcome ApigatewayClient::DescribeServiceEnvironmentStrategy(const DescribeServiceEnvironmentStrategyRequest &request)
{
auto outcome = MakeRequest(request, "DescribeServiceEnvironmentStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServiceEnvironmentStrategyResponse rsp = DescribeServiceEnvironmentStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServiceEnvironmentStrategyOutcome(rsp);
else
return DescribeServiceEnvironmentStrategyOutcome(o.GetError());
}
else
{
return DescribeServiceEnvironmentStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServiceEnvironmentStrategyAsync(const DescribeServiceEnvironmentStrategyRequest& request, const DescribeServiceEnvironmentStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeServiceEnvironmentStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServiceEnvironmentStrategyOutcomeCallable ApigatewayClient::DescribeServiceEnvironmentStrategyCallable(const DescribeServiceEnvironmentStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServiceEnvironmentStrategyOutcome()>>(
[this, request]()
{
return this->DescribeServiceEnvironmentStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServiceForApiAppOutcome ApigatewayClient::DescribeServiceForApiApp(const DescribeServiceForApiAppRequest &request)
{
auto outcome = MakeRequest(request, "DescribeServiceForApiApp");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServiceForApiAppResponse rsp = DescribeServiceForApiAppResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServiceForApiAppOutcome(rsp);
else
return DescribeServiceForApiAppOutcome(o.GetError());
}
else
{
return DescribeServiceForApiAppOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServiceForApiAppAsync(const DescribeServiceForApiAppRequest& request, const DescribeServiceForApiAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeServiceForApiApp(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServiceForApiAppOutcomeCallable ApigatewayClient::DescribeServiceForApiAppCallable(const DescribeServiceForApiAppRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServiceForApiAppOutcome()>>(
[this, request]()
{
return this->DescribeServiceForApiApp(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServiceReleaseVersionOutcome ApigatewayClient::DescribeServiceReleaseVersion(const DescribeServiceReleaseVersionRequest &request)
{
auto outcome = MakeRequest(request, "DescribeServiceReleaseVersion");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServiceReleaseVersionResponse rsp = DescribeServiceReleaseVersionResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServiceReleaseVersionOutcome(rsp);
else
return DescribeServiceReleaseVersionOutcome(o.GetError());
}
else
{
return DescribeServiceReleaseVersionOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServiceReleaseVersionAsync(const DescribeServiceReleaseVersionRequest& request, const DescribeServiceReleaseVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeServiceReleaseVersion(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServiceReleaseVersionOutcomeCallable ApigatewayClient::DescribeServiceReleaseVersionCallable(const DescribeServiceReleaseVersionRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServiceReleaseVersionOutcome()>>(
[this, request]()
{
return this->DescribeServiceReleaseVersion(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServiceSubDomainMappingsOutcome ApigatewayClient::DescribeServiceSubDomainMappings(const DescribeServiceSubDomainMappingsRequest &request)
{
auto outcome = MakeRequest(request, "DescribeServiceSubDomainMappings");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServiceSubDomainMappingsResponse rsp = DescribeServiceSubDomainMappingsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServiceSubDomainMappingsOutcome(rsp);
else
return DescribeServiceSubDomainMappingsOutcome(o.GetError());
}
else
{
return DescribeServiceSubDomainMappingsOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServiceSubDomainMappingsAsync(const DescribeServiceSubDomainMappingsRequest& request, const DescribeServiceSubDomainMappingsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeServiceSubDomainMappings(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServiceSubDomainMappingsOutcomeCallable ApigatewayClient::DescribeServiceSubDomainMappingsCallable(const DescribeServiceSubDomainMappingsRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServiceSubDomainMappingsOutcome()>>(
[this, request]()
{
return this->DescribeServiceSubDomainMappings(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServiceSubDomainsOutcome ApigatewayClient::DescribeServiceSubDomains(const DescribeServiceSubDomainsRequest &request)
{
auto outcome = MakeRequest(request, "DescribeServiceSubDomains");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServiceSubDomainsResponse rsp = DescribeServiceSubDomainsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServiceSubDomainsOutcome(rsp);
else
return DescribeServiceSubDomainsOutcome(o.GetError());
}
else
{
return DescribeServiceSubDomainsOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServiceSubDomainsAsync(const DescribeServiceSubDomainsRequest& request, const DescribeServiceSubDomainsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeServiceSubDomains(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServiceSubDomainsOutcomeCallable ApigatewayClient::DescribeServiceSubDomainsCallable(const DescribeServiceSubDomainsRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServiceSubDomainsOutcome()>>(
[this, request]()
{
return this->DescribeServiceSubDomains(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServiceUsagePlanOutcome ApigatewayClient::DescribeServiceUsagePlan(const DescribeServiceUsagePlanRequest &request)
{
auto outcome = MakeRequest(request, "DescribeServiceUsagePlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServiceUsagePlanResponse rsp = DescribeServiceUsagePlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServiceUsagePlanOutcome(rsp);
else
return DescribeServiceUsagePlanOutcome(o.GetError());
}
else
{
return DescribeServiceUsagePlanOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServiceUsagePlanAsync(const DescribeServiceUsagePlanRequest& request, const DescribeServiceUsagePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeServiceUsagePlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServiceUsagePlanOutcomeCallable ApigatewayClient::DescribeServiceUsagePlanCallable(const DescribeServiceUsagePlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServiceUsagePlanOutcome()>>(
[this, request]()
{
return this->DescribeServiceUsagePlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeServicesStatusOutcome ApigatewayClient::DescribeServicesStatus(const DescribeServicesStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeServicesStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeServicesStatusResponse rsp = DescribeServicesStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeServicesStatusOutcome(rsp);
else
return DescribeServicesStatusOutcome(o.GetError());
}
else
{
return DescribeServicesStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeServicesStatusAsync(const DescribeServicesStatusRequest& request, const DescribeServicesStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeServicesStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeServicesStatusOutcomeCallable ApigatewayClient::DescribeServicesStatusCallable(const DescribeServicesStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeServicesStatusOutcome()>>(
[this, request]()
{
return this->DescribeServicesStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeUpstreamBindApisOutcome ApigatewayClient::DescribeUpstreamBindApis(const DescribeUpstreamBindApisRequest &request)
{
auto outcome = MakeRequest(request, "DescribeUpstreamBindApis");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeUpstreamBindApisResponse rsp = DescribeUpstreamBindApisResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeUpstreamBindApisOutcome(rsp);
else
return DescribeUpstreamBindApisOutcome(o.GetError());
}
else
{
return DescribeUpstreamBindApisOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeUpstreamBindApisAsync(const DescribeUpstreamBindApisRequest& request, const DescribeUpstreamBindApisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeUpstreamBindApis(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeUpstreamBindApisOutcomeCallable ApigatewayClient::DescribeUpstreamBindApisCallable(const DescribeUpstreamBindApisRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeUpstreamBindApisOutcome()>>(
[this, request]()
{
return this->DescribeUpstreamBindApis(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeUpstreamsOutcome ApigatewayClient::DescribeUpstreams(const DescribeUpstreamsRequest &request)
{
auto outcome = MakeRequest(request, "DescribeUpstreams");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeUpstreamsResponse rsp = DescribeUpstreamsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeUpstreamsOutcome(rsp);
else
return DescribeUpstreamsOutcome(o.GetError());
}
else
{
return DescribeUpstreamsOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeUpstreamsAsync(const DescribeUpstreamsRequest& request, const DescribeUpstreamsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeUpstreams(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeUpstreamsOutcomeCallable ApigatewayClient::DescribeUpstreamsCallable(const DescribeUpstreamsRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeUpstreamsOutcome()>>(
[this, request]()
{
return this->DescribeUpstreams(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeUsagePlanOutcome ApigatewayClient::DescribeUsagePlan(const DescribeUsagePlanRequest &request)
{
auto outcome = MakeRequest(request, "DescribeUsagePlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeUsagePlanResponse rsp = DescribeUsagePlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeUsagePlanOutcome(rsp);
else
return DescribeUsagePlanOutcome(o.GetError());
}
else
{
return DescribeUsagePlanOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeUsagePlanAsync(const DescribeUsagePlanRequest& request, const DescribeUsagePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeUsagePlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeUsagePlanOutcomeCallable ApigatewayClient::DescribeUsagePlanCallable(const DescribeUsagePlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeUsagePlanOutcome()>>(
[this, request]()
{
return this->DescribeUsagePlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeUsagePlanEnvironmentsOutcome ApigatewayClient::DescribeUsagePlanEnvironments(const DescribeUsagePlanEnvironmentsRequest &request)
{
auto outcome = MakeRequest(request, "DescribeUsagePlanEnvironments");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeUsagePlanEnvironmentsResponse rsp = DescribeUsagePlanEnvironmentsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeUsagePlanEnvironmentsOutcome(rsp);
else
return DescribeUsagePlanEnvironmentsOutcome(o.GetError());
}
else
{
return DescribeUsagePlanEnvironmentsOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeUsagePlanEnvironmentsAsync(const DescribeUsagePlanEnvironmentsRequest& request, const DescribeUsagePlanEnvironmentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeUsagePlanEnvironments(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeUsagePlanEnvironmentsOutcomeCallable ApigatewayClient::DescribeUsagePlanEnvironmentsCallable(const DescribeUsagePlanEnvironmentsRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeUsagePlanEnvironmentsOutcome()>>(
[this, request]()
{
return this->DescribeUsagePlanEnvironments(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeUsagePlanSecretIdsOutcome ApigatewayClient::DescribeUsagePlanSecretIds(const DescribeUsagePlanSecretIdsRequest &request)
{
auto outcome = MakeRequest(request, "DescribeUsagePlanSecretIds");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeUsagePlanSecretIdsResponse rsp = DescribeUsagePlanSecretIdsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeUsagePlanSecretIdsOutcome(rsp);
else
return DescribeUsagePlanSecretIdsOutcome(o.GetError());
}
else
{
return DescribeUsagePlanSecretIdsOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeUsagePlanSecretIdsAsync(const DescribeUsagePlanSecretIdsRequest& request, const DescribeUsagePlanSecretIdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeUsagePlanSecretIds(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeUsagePlanSecretIdsOutcomeCallable ApigatewayClient::DescribeUsagePlanSecretIdsCallable(const DescribeUsagePlanSecretIdsRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeUsagePlanSecretIdsOutcome()>>(
[this, request]()
{
return this->DescribeUsagePlanSecretIds(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DescribeUsagePlansStatusOutcome ApigatewayClient::DescribeUsagePlansStatus(const DescribeUsagePlansStatusRequest &request)
{
auto outcome = MakeRequest(request, "DescribeUsagePlansStatus");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DescribeUsagePlansStatusResponse rsp = DescribeUsagePlansStatusResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DescribeUsagePlansStatusOutcome(rsp);
else
return DescribeUsagePlansStatusOutcome(o.GetError());
}
else
{
return DescribeUsagePlansStatusOutcome(outcome.GetError());
}
}
void ApigatewayClient::DescribeUsagePlansStatusAsync(const DescribeUsagePlansStatusRequest& request, const DescribeUsagePlansStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DescribeUsagePlansStatus(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DescribeUsagePlansStatusOutcomeCallable ApigatewayClient::DescribeUsagePlansStatusCallable(const DescribeUsagePlansStatusRequest &request)
{
auto task = std::make_shared<std::packaged_task<DescribeUsagePlansStatusOutcome()>>(
[this, request]()
{
return this->DescribeUsagePlansStatus(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DetachPluginOutcome ApigatewayClient::DetachPlugin(const DetachPluginRequest &request)
{
auto outcome = MakeRequest(request, "DetachPlugin");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DetachPluginResponse rsp = DetachPluginResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DetachPluginOutcome(rsp);
else
return DetachPluginOutcome(o.GetError());
}
else
{
return DetachPluginOutcome(outcome.GetError());
}
}
void ApigatewayClient::DetachPluginAsync(const DetachPluginRequest& request, const DetachPluginAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DetachPlugin(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DetachPluginOutcomeCallable ApigatewayClient::DetachPluginCallable(const DetachPluginRequest &request)
{
auto task = std::make_shared<std::packaged_task<DetachPluginOutcome()>>(
[this, request]()
{
return this->DetachPlugin(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::DisableApiKeyOutcome ApigatewayClient::DisableApiKey(const DisableApiKeyRequest &request)
{
auto outcome = MakeRequest(request, "DisableApiKey");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
DisableApiKeyResponse rsp = DisableApiKeyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return DisableApiKeyOutcome(rsp);
else
return DisableApiKeyOutcome(o.GetError());
}
else
{
return DisableApiKeyOutcome(outcome.GetError());
}
}
void ApigatewayClient::DisableApiKeyAsync(const DisableApiKeyRequest& request, const DisableApiKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->DisableApiKey(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::DisableApiKeyOutcomeCallable ApigatewayClient::DisableApiKeyCallable(const DisableApiKeyRequest &request)
{
auto task = std::make_shared<std::packaged_task<DisableApiKeyOutcome()>>(
[this, request]()
{
return this->DisableApiKey(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::EnableApiKeyOutcome ApigatewayClient::EnableApiKey(const EnableApiKeyRequest &request)
{
auto outcome = MakeRequest(request, "EnableApiKey");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
EnableApiKeyResponse rsp = EnableApiKeyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return EnableApiKeyOutcome(rsp);
else
return EnableApiKeyOutcome(o.GetError());
}
else
{
return EnableApiKeyOutcome(outcome.GetError());
}
}
void ApigatewayClient::EnableApiKeyAsync(const EnableApiKeyRequest& request, const EnableApiKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->EnableApiKey(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::EnableApiKeyOutcomeCallable ApigatewayClient::EnableApiKeyCallable(const EnableApiKeyRequest &request)
{
auto task = std::make_shared<std::packaged_task<EnableApiKeyOutcome()>>(
[this, request]()
{
return this->EnableApiKey(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ImportOpenApiOutcome ApigatewayClient::ImportOpenApi(const ImportOpenApiRequest &request)
{
auto outcome = MakeRequest(request, "ImportOpenApi");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ImportOpenApiResponse rsp = ImportOpenApiResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ImportOpenApiOutcome(rsp);
else
return ImportOpenApiOutcome(o.GetError());
}
else
{
return ImportOpenApiOutcome(outcome.GetError());
}
}
void ApigatewayClient::ImportOpenApiAsync(const ImportOpenApiRequest& request, const ImportOpenApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ImportOpenApi(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ImportOpenApiOutcomeCallable ApigatewayClient::ImportOpenApiCallable(const ImportOpenApiRequest &request)
{
auto task = std::make_shared<std::packaged_task<ImportOpenApiOutcome()>>(
[this, request]()
{
return this->ImportOpenApi(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyAPIDocOutcome ApigatewayClient::ModifyAPIDoc(const ModifyAPIDocRequest &request)
{
auto outcome = MakeRequest(request, "ModifyAPIDoc");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyAPIDocResponse rsp = ModifyAPIDocResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyAPIDocOutcome(rsp);
else
return ModifyAPIDocOutcome(o.GetError());
}
else
{
return ModifyAPIDocOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyAPIDocAsync(const ModifyAPIDocRequest& request, const ModifyAPIDocAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyAPIDoc(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyAPIDocOutcomeCallable ApigatewayClient::ModifyAPIDocCallable(const ModifyAPIDocRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyAPIDocOutcome()>>(
[this, request]()
{
return this->ModifyAPIDoc(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyApiOutcome ApigatewayClient::ModifyApi(const ModifyApiRequest &request)
{
auto outcome = MakeRequest(request, "ModifyApi");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyApiResponse rsp = ModifyApiResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyApiOutcome(rsp);
else
return ModifyApiOutcome(o.GetError());
}
else
{
return ModifyApiOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyApiAsync(const ModifyApiRequest& request, const ModifyApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyApi(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyApiOutcomeCallable ApigatewayClient::ModifyApiCallable(const ModifyApiRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyApiOutcome()>>(
[this, request]()
{
return this->ModifyApi(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyApiAppOutcome ApigatewayClient::ModifyApiApp(const ModifyApiAppRequest &request)
{
auto outcome = MakeRequest(request, "ModifyApiApp");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyApiAppResponse rsp = ModifyApiAppResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyApiAppOutcome(rsp);
else
return ModifyApiAppOutcome(o.GetError());
}
else
{
return ModifyApiAppOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyApiAppAsync(const ModifyApiAppRequest& request, const ModifyApiAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyApiApp(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyApiAppOutcomeCallable ApigatewayClient::ModifyApiAppCallable(const ModifyApiAppRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyApiAppOutcome()>>(
[this, request]()
{
return this->ModifyApiApp(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyApiEnvironmentStrategyOutcome ApigatewayClient::ModifyApiEnvironmentStrategy(const ModifyApiEnvironmentStrategyRequest &request)
{
auto outcome = MakeRequest(request, "ModifyApiEnvironmentStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyApiEnvironmentStrategyResponse rsp = ModifyApiEnvironmentStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyApiEnvironmentStrategyOutcome(rsp);
else
return ModifyApiEnvironmentStrategyOutcome(o.GetError());
}
else
{
return ModifyApiEnvironmentStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyApiEnvironmentStrategyAsync(const ModifyApiEnvironmentStrategyRequest& request, const ModifyApiEnvironmentStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyApiEnvironmentStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyApiEnvironmentStrategyOutcomeCallable ApigatewayClient::ModifyApiEnvironmentStrategyCallable(const ModifyApiEnvironmentStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyApiEnvironmentStrategyOutcome()>>(
[this, request]()
{
return this->ModifyApiEnvironmentStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyApiIncrementOutcome ApigatewayClient::ModifyApiIncrement(const ModifyApiIncrementRequest &request)
{
auto outcome = MakeRequest(request, "ModifyApiIncrement");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyApiIncrementResponse rsp = ModifyApiIncrementResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyApiIncrementOutcome(rsp);
else
return ModifyApiIncrementOutcome(o.GetError());
}
else
{
return ModifyApiIncrementOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyApiIncrementAsync(const ModifyApiIncrementRequest& request, const ModifyApiIncrementAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyApiIncrement(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyApiIncrementOutcomeCallable ApigatewayClient::ModifyApiIncrementCallable(const ModifyApiIncrementRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyApiIncrementOutcome()>>(
[this, request]()
{
return this->ModifyApiIncrement(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyExclusiveInstanceOutcome ApigatewayClient::ModifyExclusiveInstance(const ModifyExclusiveInstanceRequest &request)
{
auto outcome = MakeRequest(request, "ModifyExclusiveInstance");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyExclusiveInstanceResponse rsp = ModifyExclusiveInstanceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyExclusiveInstanceOutcome(rsp);
else
return ModifyExclusiveInstanceOutcome(o.GetError());
}
else
{
return ModifyExclusiveInstanceOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyExclusiveInstanceAsync(const ModifyExclusiveInstanceRequest& request, const ModifyExclusiveInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyExclusiveInstance(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyExclusiveInstanceOutcomeCallable ApigatewayClient::ModifyExclusiveInstanceCallable(const ModifyExclusiveInstanceRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyExclusiveInstanceOutcome()>>(
[this, request]()
{
return this->ModifyExclusiveInstance(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyIPStrategyOutcome ApigatewayClient::ModifyIPStrategy(const ModifyIPStrategyRequest &request)
{
auto outcome = MakeRequest(request, "ModifyIPStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyIPStrategyResponse rsp = ModifyIPStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyIPStrategyOutcome(rsp);
else
return ModifyIPStrategyOutcome(o.GetError());
}
else
{
return ModifyIPStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyIPStrategyAsync(const ModifyIPStrategyRequest& request, const ModifyIPStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyIPStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyIPStrategyOutcomeCallable ApigatewayClient::ModifyIPStrategyCallable(const ModifyIPStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyIPStrategyOutcome()>>(
[this, request]()
{
return this->ModifyIPStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyPluginOutcome ApigatewayClient::ModifyPlugin(const ModifyPluginRequest &request)
{
auto outcome = MakeRequest(request, "ModifyPlugin");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyPluginResponse rsp = ModifyPluginResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyPluginOutcome(rsp);
else
return ModifyPluginOutcome(o.GetError());
}
else
{
return ModifyPluginOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyPluginAsync(const ModifyPluginRequest& request, const ModifyPluginAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyPlugin(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyPluginOutcomeCallable ApigatewayClient::ModifyPluginCallable(const ModifyPluginRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyPluginOutcome()>>(
[this, request]()
{
return this->ModifyPlugin(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyServiceOutcome ApigatewayClient::ModifyService(const ModifyServiceRequest &request)
{
auto outcome = MakeRequest(request, "ModifyService");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyServiceResponse rsp = ModifyServiceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyServiceOutcome(rsp);
else
return ModifyServiceOutcome(o.GetError());
}
else
{
return ModifyServiceOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyServiceAsync(const ModifyServiceRequest& request, const ModifyServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyService(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyServiceOutcomeCallable ApigatewayClient::ModifyServiceCallable(const ModifyServiceRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyServiceOutcome()>>(
[this, request]()
{
return this->ModifyService(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyServiceEnvironmentStrategyOutcome ApigatewayClient::ModifyServiceEnvironmentStrategy(const ModifyServiceEnvironmentStrategyRequest &request)
{
auto outcome = MakeRequest(request, "ModifyServiceEnvironmentStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyServiceEnvironmentStrategyResponse rsp = ModifyServiceEnvironmentStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyServiceEnvironmentStrategyOutcome(rsp);
else
return ModifyServiceEnvironmentStrategyOutcome(o.GetError());
}
else
{
return ModifyServiceEnvironmentStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyServiceEnvironmentStrategyAsync(const ModifyServiceEnvironmentStrategyRequest& request, const ModifyServiceEnvironmentStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyServiceEnvironmentStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyServiceEnvironmentStrategyOutcomeCallable ApigatewayClient::ModifyServiceEnvironmentStrategyCallable(const ModifyServiceEnvironmentStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyServiceEnvironmentStrategyOutcome()>>(
[this, request]()
{
return this->ModifyServiceEnvironmentStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifySubDomainOutcome ApigatewayClient::ModifySubDomain(const ModifySubDomainRequest &request)
{
auto outcome = MakeRequest(request, "ModifySubDomain");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifySubDomainResponse rsp = ModifySubDomainResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifySubDomainOutcome(rsp);
else
return ModifySubDomainOutcome(o.GetError());
}
else
{
return ModifySubDomainOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifySubDomainAsync(const ModifySubDomainRequest& request, const ModifySubDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifySubDomain(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifySubDomainOutcomeCallable ApigatewayClient::ModifySubDomainCallable(const ModifySubDomainRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifySubDomainOutcome()>>(
[this, request]()
{
return this->ModifySubDomain(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyUpstreamOutcome ApigatewayClient::ModifyUpstream(const ModifyUpstreamRequest &request)
{
auto outcome = MakeRequest(request, "ModifyUpstream");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyUpstreamResponse rsp = ModifyUpstreamResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyUpstreamOutcome(rsp);
else
return ModifyUpstreamOutcome(o.GetError());
}
else
{
return ModifyUpstreamOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyUpstreamAsync(const ModifyUpstreamRequest& request, const ModifyUpstreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyUpstream(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyUpstreamOutcomeCallable ApigatewayClient::ModifyUpstreamCallable(const ModifyUpstreamRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyUpstreamOutcome()>>(
[this, request]()
{
return this->ModifyUpstream(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ModifyUsagePlanOutcome ApigatewayClient::ModifyUsagePlan(const ModifyUsagePlanRequest &request)
{
auto outcome = MakeRequest(request, "ModifyUsagePlan");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ModifyUsagePlanResponse rsp = ModifyUsagePlanResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ModifyUsagePlanOutcome(rsp);
else
return ModifyUsagePlanOutcome(o.GetError());
}
else
{
return ModifyUsagePlanOutcome(outcome.GetError());
}
}
void ApigatewayClient::ModifyUsagePlanAsync(const ModifyUsagePlanRequest& request, const ModifyUsagePlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ModifyUsagePlan(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ModifyUsagePlanOutcomeCallable ApigatewayClient::ModifyUsagePlanCallable(const ModifyUsagePlanRequest &request)
{
auto task = std::make_shared<std::packaged_task<ModifyUsagePlanOutcome()>>(
[this, request]()
{
return this->ModifyUsagePlan(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ReleaseServiceOutcome ApigatewayClient::ReleaseService(const ReleaseServiceRequest &request)
{
auto outcome = MakeRequest(request, "ReleaseService");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ReleaseServiceResponse rsp = ReleaseServiceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ReleaseServiceOutcome(rsp);
else
return ReleaseServiceOutcome(o.GetError());
}
else
{
return ReleaseServiceOutcome(outcome.GetError());
}
}
void ApigatewayClient::ReleaseServiceAsync(const ReleaseServiceRequest& request, const ReleaseServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ReleaseService(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ReleaseServiceOutcomeCallable ApigatewayClient::ReleaseServiceCallable(const ReleaseServiceRequest &request)
{
auto task = std::make_shared<std::packaged_task<ReleaseServiceOutcome()>>(
[this, request]()
{
return this->ReleaseService(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::ResetAPIDocPasswordOutcome ApigatewayClient::ResetAPIDocPassword(const ResetAPIDocPasswordRequest &request)
{
auto outcome = MakeRequest(request, "ResetAPIDocPassword");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
ResetAPIDocPasswordResponse rsp = ResetAPIDocPasswordResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return ResetAPIDocPasswordOutcome(rsp);
else
return ResetAPIDocPasswordOutcome(o.GetError());
}
else
{
return ResetAPIDocPasswordOutcome(outcome.GetError());
}
}
void ApigatewayClient::ResetAPIDocPasswordAsync(const ResetAPIDocPasswordRequest& request, const ResetAPIDocPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->ResetAPIDocPassword(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::ResetAPIDocPasswordOutcomeCallable ApigatewayClient::ResetAPIDocPasswordCallable(const ResetAPIDocPasswordRequest &request)
{
auto task = std::make_shared<std::packaged_task<ResetAPIDocPasswordOutcome()>>(
[this, request]()
{
return this->ResetAPIDocPassword(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::UnBindEnvironmentOutcome ApigatewayClient::UnBindEnvironment(const UnBindEnvironmentRequest &request)
{
auto outcome = MakeRequest(request, "UnBindEnvironment");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UnBindEnvironmentResponse rsp = UnBindEnvironmentResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UnBindEnvironmentOutcome(rsp);
else
return UnBindEnvironmentOutcome(o.GetError());
}
else
{
return UnBindEnvironmentOutcome(outcome.GetError());
}
}
void ApigatewayClient::UnBindEnvironmentAsync(const UnBindEnvironmentRequest& request, const UnBindEnvironmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UnBindEnvironment(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::UnBindEnvironmentOutcomeCallable ApigatewayClient::UnBindEnvironmentCallable(const UnBindEnvironmentRequest &request)
{
auto task = std::make_shared<std::packaged_task<UnBindEnvironmentOutcome()>>(
[this, request]()
{
return this->UnBindEnvironment(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::UnBindIPStrategyOutcome ApigatewayClient::UnBindIPStrategy(const UnBindIPStrategyRequest &request)
{
auto outcome = MakeRequest(request, "UnBindIPStrategy");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UnBindIPStrategyResponse rsp = UnBindIPStrategyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UnBindIPStrategyOutcome(rsp);
else
return UnBindIPStrategyOutcome(o.GetError());
}
else
{
return UnBindIPStrategyOutcome(outcome.GetError());
}
}
void ApigatewayClient::UnBindIPStrategyAsync(const UnBindIPStrategyRequest& request, const UnBindIPStrategyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UnBindIPStrategy(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::UnBindIPStrategyOutcomeCallable ApigatewayClient::UnBindIPStrategyCallable(const UnBindIPStrategyRequest &request)
{
auto task = std::make_shared<std::packaged_task<UnBindIPStrategyOutcome()>>(
[this, request]()
{
return this->UnBindIPStrategy(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::UnBindSecretIdsOutcome ApigatewayClient::UnBindSecretIds(const UnBindSecretIdsRequest &request)
{
auto outcome = MakeRequest(request, "UnBindSecretIds");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UnBindSecretIdsResponse rsp = UnBindSecretIdsResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UnBindSecretIdsOutcome(rsp);
else
return UnBindSecretIdsOutcome(o.GetError());
}
else
{
return UnBindSecretIdsOutcome(outcome.GetError());
}
}
void ApigatewayClient::UnBindSecretIdsAsync(const UnBindSecretIdsRequest& request, const UnBindSecretIdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UnBindSecretIds(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::UnBindSecretIdsOutcomeCallable ApigatewayClient::UnBindSecretIdsCallable(const UnBindSecretIdsRequest &request)
{
auto task = std::make_shared<std::packaged_task<UnBindSecretIdsOutcome()>>(
[this, request]()
{
return this->UnBindSecretIds(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::UnBindSubDomainOutcome ApigatewayClient::UnBindSubDomain(const UnBindSubDomainRequest &request)
{
auto outcome = MakeRequest(request, "UnBindSubDomain");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UnBindSubDomainResponse rsp = UnBindSubDomainResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UnBindSubDomainOutcome(rsp);
else
return UnBindSubDomainOutcome(o.GetError());
}
else
{
return UnBindSubDomainOutcome(outcome.GetError());
}
}
void ApigatewayClient::UnBindSubDomainAsync(const UnBindSubDomainRequest& request, const UnBindSubDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UnBindSubDomain(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::UnBindSubDomainOutcomeCallable ApigatewayClient::UnBindSubDomainCallable(const UnBindSubDomainRequest &request)
{
auto task = std::make_shared<std::packaged_task<UnBindSubDomainOutcome()>>(
[this, request]()
{
return this->UnBindSubDomain(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::UnReleaseServiceOutcome ApigatewayClient::UnReleaseService(const UnReleaseServiceRequest &request)
{
auto outcome = MakeRequest(request, "UnReleaseService");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UnReleaseServiceResponse rsp = UnReleaseServiceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UnReleaseServiceOutcome(rsp);
else
return UnReleaseServiceOutcome(o.GetError());
}
else
{
return UnReleaseServiceOutcome(outcome.GetError());
}
}
void ApigatewayClient::UnReleaseServiceAsync(const UnReleaseServiceRequest& request, const UnReleaseServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UnReleaseService(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::UnReleaseServiceOutcomeCallable ApigatewayClient::UnReleaseServiceCallable(const UnReleaseServiceRequest &request)
{
auto task = std::make_shared<std::packaged_task<UnReleaseServiceOutcome()>>(
[this, request]()
{
return this->UnReleaseService(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::UnbindApiAppOutcome ApigatewayClient::UnbindApiApp(const UnbindApiAppRequest &request)
{
auto outcome = MakeRequest(request, "UnbindApiApp");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UnbindApiAppResponse rsp = UnbindApiAppResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UnbindApiAppOutcome(rsp);
else
return UnbindApiAppOutcome(o.GetError());
}
else
{
return UnbindApiAppOutcome(outcome.GetError());
}
}
void ApigatewayClient::UnbindApiAppAsync(const UnbindApiAppRequest& request, const UnbindApiAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UnbindApiApp(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::UnbindApiAppOutcomeCallable ApigatewayClient::UnbindApiAppCallable(const UnbindApiAppRequest &request)
{
auto task = std::make_shared<std::packaged_task<UnbindApiAppOutcome()>>(
[this, request]()
{
return this->UnbindApiApp(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::UpdateApiAppKeyOutcome ApigatewayClient::UpdateApiAppKey(const UpdateApiAppKeyRequest &request)
{
auto outcome = MakeRequest(request, "UpdateApiAppKey");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateApiAppKeyResponse rsp = UpdateApiAppKeyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateApiAppKeyOutcome(rsp);
else
return UpdateApiAppKeyOutcome(o.GetError());
}
else
{
return UpdateApiAppKeyOutcome(outcome.GetError());
}
}
void ApigatewayClient::UpdateApiAppKeyAsync(const UpdateApiAppKeyRequest& request, const UpdateApiAppKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateApiAppKey(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::UpdateApiAppKeyOutcomeCallable ApigatewayClient::UpdateApiAppKeyCallable(const UpdateApiAppKeyRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateApiAppKeyOutcome()>>(
[this, request]()
{
return this->UpdateApiAppKey(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::UpdateApiKeyOutcome ApigatewayClient::UpdateApiKey(const UpdateApiKeyRequest &request)
{
auto outcome = MakeRequest(request, "UpdateApiKey");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateApiKeyResponse rsp = UpdateApiKeyResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateApiKeyOutcome(rsp);
else
return UpdateApiKeyOutcome(o.GetError());
}
else
{
return UpdateApiKeyOutcome(outcome.GetError());
}
}
void ApigatewayClient::UpdateApiKeyAsync(const UpdateApiKeyRequest& request, const UpdateApiKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateApiKey(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::UpdateApiKeyOutcomeCallable ApigatewayClient::UpdateApiKeyCallable(const UpdateApiKeyRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateApiKeyOutcome()>>(
[this, request]()
{
return this->UpdateApiKey(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
ApigatewayClient::UpdateServiceOutcome ApigatewayClient::UpdateService(const UpdateServiceRequest &request)
{
auto outcome = MakeRequest(request, "UpdateService");
if (outcome.IsSuccess())
{
auto r = outcome.GetResult();
string payload = string(r.Body(), r.BodySize());
UpdateServiceResponse rsp = UpdateServiceResponse();
auto o = rsp.Deserialize(payload);
if (o.IsSuccess())
return UpdateServiceOutcome(rsp);
else
return UpdateServiceOutcome(o.GetError());
}
else
{
return UpdateServiceOutcome(outcome.GetError());
}
}
void ApigatewayClient::UpdateServiceAsync(const UpdateServiceRequest& request, const UpdateServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context)
{
auto fn = [this, request, handler, context]()
{
handler(this, request, this->UpdateService(request), context);
};
Executor::GetInstance()->Submit(new Runnable(fn));
}
ApigatewayClient::UpdateServiceOutcomeCallable ApigatewayClient::UpdateServiceCallable(const UpdateServiceRequest &request)
{
auto task = std::make_shared<std::packaged_task<UpdateServiceOutcome()>>(
[this, request]()
{
return this->UpdateService(request);
}
);
Executor::GetInstance()->Submit(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。