1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2345df949e94d1e350c418513333a32df08b81d0
aliyun-openapi-cpp-sdk/ddosbgp/src/DdosbgpClient.cc
sdk-team e7391bcf60 Update sdk.
2023-06-25 09:43:37 +00:00

1026 lines
35 KiB
C++
Raw Blame History

/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/ddosbgp/DdosbgpClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Ddosbgp;
using namespace AlibabaCloud::Ddosbgp::Model;
namespace
{
const std::string SERVICE_NAME = "ddosbgp";
}
DdosbgpClient::DdosbgpClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
DdosbgpClient::DdosbgpClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
DdosbgpClient::DdosbgpClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
}
DdosbgpClient::~DdosbgpClient()
{}
DdosbgpClient::AddIpOutcome DdosbgpClient::addIp(const AddIpRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AddIpOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AddIpOutcome(AddIpResult(outcome.result()));
else
return AddIpOutcome(outcome.error());
}
void DdosbgpClient::addIpAsync(const AddIpRequest& request, const AddIpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, addIp(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::AddIpOutcomeCallable DdosbgpClient::addIpCallable(const AddIpRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AddIpOutcome()>>(
[this, request]()
{
return this->addIp(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::CheckAccessLogAuthOutcome DdosbgpClient::checkAccessLogAuth(const CheckAccessLogAuthRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckAccessLogAuthOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckAccessLogAuthOutcome(CheckAccessLogAuthResult(outcome.result()));
else
return CheckAccessLogAuthOutcome(outcome.error());
}
void DdosbgpClient::checkAccessLogAuthAsync(const CheckAccessLogAuthRequest& request, const CheckAccessLogAuthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkAccessLogAuth(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::CheckAccessLogAuthOutcomeCallable DdosbgpClient::checkAccessLogAuthCallable(const CheckAccessLogAuthRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckAccessLogAuthOutcome()>>(
[this, request]()
{
return this->checkAccessLogAuth(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::CheckGrantOutcome DdosbgpClient::checkGrant(const CheckGrantRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckGrantOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckGrantOutcome(CheckGrantResult(outcome.result()));
else
return CheckGrantOutcome(outcome.error());
}
void DdosbgpClient::checkGrantAsync(const CheckGrantRequest& request, const CheckGrantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkGrant(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::CheckGrantOutcomeCallable DdosbgpClient::checkGrantCallable(const CheckGrantRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckGrantOutcome()>>(
[this, request]()
{
return this->checkGrant(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::ConfigSchedruleOnDemandOutcome DdosbgpClient::configSchedruleOnDemand(const ConfigSchedruleOnDemandRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ConfigSchedruleOnDemandOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ConfigSchedruleOnDemandOutcome(ConfigSchedruleOnDemandResult(outcome.result()));
else
return ConfigSchedruleOnDemandOutcome(outcome.error());
}
void DdosbgpClient::configSchedruleOnDemandAsync(const ConfigSchedruleOnDemandRequest& request, const ConfigSchedruleOnDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, configSchedruleOnDemand(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::ConfigSchedruleOnDemandOutcomeCallable DdosbgpClient::configSchedruleOnDemandCallable(const ConfigSchedruleOnDemandRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ConfigSchedruleOnDemandOutcome()>>(
[this, request]()
{
return this->configSchedruleOnDemand(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::CreateSchedruleOnDemandOutcome DdosbgpClient::createSchedruleOnDemand(const CreateSchedruleOnDemandRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateSchedruleOnDemandOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateSchedruleOnDemandOutcome(CreateSchedruleOnDemandResult(outcome.result()));
else
return CreateSchedruleOnDemandOutcome(outcome.error());
}
void DdosbgpClient::createSchedruleOnDemandAsync(const CreateSchedruleOnDemandRequest& request, const CreateSchedruleOnDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createSchedruleOnDemand(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::CreateSchedruleOnDemandOutcomeCallable DdosbgpClient::createSchedruleOnDemandCallable(const CreateSchedruleOnDemandRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateSchedruleOnDemandOutcome()>>(
[this, request]()
{
return this->createSchedruleOnDemand(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DeleteBlackholeOutcome DdosbgpClient::deleteBlackhole(const DeleteBlackholeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteBlackholeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteBlackholeOutcome(DeleteBlackholeResult(outcome.result()));
else
return DeleteBlackholeOutcome(outcome.error());
}
void DdosbgpClient::deleteBlackholeAsync(const DeleteBlackholeRequest& request, const DeleteBlackholeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteBlackhole(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DeleteBlackholeOutcomeCallable DdosbgpClient::deleteBlackholeCallable(const DeleteBlackholeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteBlackholeOutcome()>>(
[this, request]()
{
return this->deleteBlackhole(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DeleteIpOutcome DdosbgpClient::deleteIp(const DeleteIpRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteIpOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteIpOutcome(DeleteIpResult(outcome.result()));
else
return DeleteIpOutcome(outcome.error());
}
void DdosbgpClient::deleteIpAsync(const DeleteIpRequest& request, const DeleteIpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteIp(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DeleteIpOutcomeCallable DdosbgpClient::deleteIpCallable(const DeleteIpRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteIpOutcome()>>(
[this, request]()
{
return this->deleteIp(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DeleteSchedruleOnDemandOutcome DdosbgpClient::deleteSchedruleOnDemand(const DeleteSchedruleOnDemandRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteSchedruleOnDemandOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteSchedruleOnDemandOutcome(DeleteSchedruleOnDemandResult(outcome.result()));
else
return DeleteSchedruleOnDemandOutcome(outcome.error());
}
void DdosbgpClient::deleteSchedruleOnDemandAsync(const DeleteSchedruleOnDemandRequest& request, const DeleteSchedruleOnDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteSchedruleOnDemand(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DeleteSchedruleOnDemandOutcomeCallable DdosbgpClient::deleteSchedruleOnDemandCallable(const DeleteSchedruleOnDemandRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteSchedruleOnDemandOutcome()>>(
[this, request]()
{
return this->deleteSchedruleOnDemand(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribeDdosEventOutcome DdosbgpClient::describeDdosEvent(const DescribeDdosEventRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDdosEventOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDdosEventOutcome(DescribeDdosEventResult(outcome.result()));
else
return DescribeDdosEventOutcome(outcome.error());
}
void DdosbgpClient::describeDdosEventAsync(const DescribeDdosEventRequest& request, const DescribeDdosEventAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDdosEvent(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribeDdosEventOutcomeCallable DdosbgpClient::describeDdosEventCallable(const DescribeDdosEventRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDdosEventOutcome()>>(
[this, request]()
{
return this->describeDdosEvent(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribeExcpetionCountOutcome DdosbgpClient::describeExcpetionCount(const DescribeExcpetionCountRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeExcpetionCountOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeExcpetionCountOutcome(DescribeExcpetionCountResult(outcome.result()));
else
return DescribeExcpetionCountOutcome(outcome.error());
}
void DdosbgpClient::describeExcpetionCountAsync(const DescribeExcpetionCountRequest& request, const DescribeExcpetionCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeExcpetionCount(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribeExcpetionCountOutcomeCallable DdosbgpClient::describeExcpetionCountCallable(const DescribeExcpetionCountRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeExcpetionCountOutcome()>>(
[this, request]()
{
return this->describeExcpetionCount(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribeInstanceListOutcome DdosbgpClient::describeInstanceList(const DescribeInstanceListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeInstanceListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeInstanceListOutcome(DescribeInstanceListResult(outcome.result()));
else
return DescribeInstanceListOutcome(outcome.error());
}
void DdosbgpClient::describeInstanceListAsync(const DescribeInstanceListRequest& request, const DescribeInstanceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeInstanceList(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribeInstanceListOutcomeCallable DdosbgpClient::describeInstanceListCallable(const DescribeInstanceListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeInstanceListOutcome()>>(
[this, request]()
{
return this->describeInstanceList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribeInstanceSpecsOutcome DdosbgpClient::describeInstanceSpecs(const DescribeInstanceSpecsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeInstanceSpecsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeInstanceSpecsOutcome(DescribeInstanceSpecsResult(outcome.result()));
else
return DescribeInstanceSpecsOutcome(outcome.error());
}
void DdosbgpClient::describeInstanceSpecsAsync(const DescribeInstanceSpecsRequest& request, const DescribeInstanceSpecsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeInstanceSpecs(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribeInstanceSpecsOutcomeCallable DdosbgpClient::describeInstanceSpecsCallable(const DescribeInstanceSpecsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeInstanceSpecsOutcome()>>(
[this, request]()
{
return this->describeInstanceSpecs(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribeOnDemandDdosEventOutcome DdosbgpClient::describeOnDemandDdosEvent(const DescribeOnDemandDdosEventRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeOnDemandDdosEventOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeOnDemandDdosEventOutcome(DescribeOnDemandDdosEventResult(outcome.result()));
else
return DescribeOnDemandDdosEventOutcome(outcome.error());
}
void DdosbgpClient::describeOnDemandDdosEventAsync(const DescribeOnDemandDdosEventRequest& request, const DescribeOnDemandDdosEventAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeOnDemandDdosEvent(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribeOnDemandDdosEventOutcomeCallable DdosbgpClient::describeOnDemandDdosEventCallable(const DescribeOnDemandDdosEventRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeOnDemandDdosEventOutcome()>>(
[this, request]()
{
return this->describeOnDemandDdosEvent(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribeOnDemandInstanceStatusOutcome DdosbgpClient::describeOnDemandInstanceStatus(const DescribeOnDemandInstanceStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeOnDemandInstanceStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeOnDemandInstanceStatusOutcome(DescribeOnDemandInstanceStatusResult(outcome.result()));
else
return DescribeOnDemandInstanceStatusOutcome(outcome.error());
}
void DdosbgpClient::describeOnDemandInstanceStatusAsync(const DescribeOnDemandInstanceStatusRequest& request, const DescribeOnDemandInstanceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeOnDemandInstanceStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribeOnDemandInstanceStatusOutcomeCallable DdosbgpClient::describeOnDemandInstanceStatusCallable(const DescribeOnDemandInstanceStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeOnDemandInstanceStatusOutcome()>>(
[this, request]()
{
return this->describeOnDemandInstanceStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribeOpEntitiesOutcome DdosbgpClient::describeOpEntities(const DescribeOpEntitiesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeOpEntitiesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeOpEntitiesOutcome(DescribeOpEntitiesResult(outcome.result()));
else
return DescribeOpEntitiesOutcome(outcome.error());
}
void DdosbgpClient::describeOpEntitiesAsync(const DescribeOpEntitiesRequest& request, const DescribeOpEntitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeOpEntities(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribeOpEntitiesOutcomeCallable DdosbgpClient::describeOpEntitiesCallable(const DescribeOpEntitiesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeOpEntitiesOutcome()>>(
[this, request]()
{
return this->describeOpEntities(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribePackIpListOutcome DdosbgpClient::describePackIpList(const DescribePackIpListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribePackIpListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribePackIpListOutcome(DescribePackIpListResult(outcome.result()));
else
return DescribePackIpListOutcome(outcome.error());
}
void DdosbgpClient::describePackIpListAsync(const DescribePackIpListRequest& request, const DescribePackIpListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describePackIpList(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribePackIpListOutcomeCallable DdosbgpClient::describePackIpListCallable(const DescribePackIpListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribePackIpListOutcome()>>(
[this, request]()
{
return this->describePackIpList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribeRegionsOutcome DdosbgpClient::describeRegions(const DescribeRegionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeRegionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
else
return DescribeRegionsOutcome(outcome.error());
}
void DdosbgpClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeRegions(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribeRegionsOutcomeCallable DdosbgpClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
[this, request]()
{
return this->describeRegions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::DescribeTrafficOutcome DdosbgpClient::describeTraffic(const DescribeTrafficRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeTrafficOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeTrafficOutcome(DescribeTrafficResult(outcome.result()));
else
return DescribeTrafficOutcome(outcome.error());
}
void DdosbgpClient::describeTrafficAsync(const DescribeTrafficRequest& request, const DescribeTrafficAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeTraffic(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::DescribeTrafficOutcomeCallable DdosbgpClient::describeTrafficCallable(const DescribeTrafficRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeTrafficOutcome()>>(
[this, request]()
{
return this->describeTraffic(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::GetSlsOpenStatusOutcome DdosbgpClient::getSlsOpenStatus(const GetSlsOpenStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetSlsOpenStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetSlsOpenStatusOutcome(GetSlsOpenStatusResult(outcome.result()));
else
return GetSlsOpenStatusOutcome(outcome.error());
}
void DdosbgpClient::getSlsOpenStatusAsync(const GetSlsOpenStatusRequest& request, const GetSlsOpenStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getSlsOpenStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::GetSlsOpenStatusOutcomeCallable DdosbgpClient::getSlsOpenStatusCallable(const GetSlsOpenStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetSlsOpenStatusOutcome()>>(
[this, request]()
{
return this->getSlsOpenStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::ListOpenedAccessLogInstancesOutcome DdosbgpClient::listOpenedAccessLogInstances(const ListOpenedAccessLogInstancesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListOpenedAccessLogInstancesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListOpenedAccessLogInstancesOutcome(ListOpenedAccessLogInstancesResult(outcome.result()));
else
return ListOpenedAccessLogInstancesOutcome(outcome.error());
}
void DdosbgpClient::listOpenedAccessLogInstancesAsync(const ListOpenedAccessLogInstancesRequest& request, const ListOpenedAccessLogInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listOpenedAccessLogInstances(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::ListOpenedAccessLogInstancesOutcomeCallable DdosbgpClient::listOpenedAccessLogInstancesCallable(const ListOpenedAccessLogInstancesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListOpenedAccessLogInstancesOutcome()>>(
[this, request]()
{
return this->listOpenedAccessLogInstances(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::ListTagKeysOutcome DdosbgpClient::listTagKeys(const ListTagKeysRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTagKeysOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTagKeysOutcome(ListTagKeysResult(outcome.result()));
else
return ListTagKeysOutcome(outcome.error());
}
void DdosbgpClient::listTagKeysAsync(const ListTagKeysRequest& request, const ListTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTagKeys(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::ListTagKeysOutcomeCallable DdosbgpClient::listTagKeysCallable(const ListTagKeysRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTagKeysOutcome()>>(
[this, request]()
{
return this->listTagKeys(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::ListTagResourcesOutcome DdosbgpClient::listTagResources(const ListTagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ListTagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ListTagResourcesOutcome(ListTagResourcesResult(outcome.result()));
else
return ListTagResourcesOutcome(outcome.error());
}
void DdosbgpClient::listTagResourcesAsync(const ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, listTagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::ListTagResourcesOutcomeCallable DdosbgpClient::listTagResourcesCallable(const ListTagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ListTagResourcesOutcome()>>(
[this, request]()
{
return this->listTagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::ModifyRemarkOutcome DdosbgpClient::modifyRemark(const ModifyRemarkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyRemarkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyRemarkOutcome(ModifyRemarkResult(outcome.result()));
else
return ModifyRemarkOutcome(outcome.error());
}
void DdosbgpClient::modifyRemarkAsync(const ModifyRemarkRequest& request, const ModifyRemarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyRemark(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::ModifyRemarkOutcomeCallable DdosbgpClient::modifyRemarkCallable(const ModifyRemarkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyRemarkOutcome()>>(
[this, request]()
{
return this->modifyRemark(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::QuerySchedruleOnDemandOutcome DdosbgpClient::querySchedruleOnDemand(const QuerySchedruleOnDemandRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return QuerySchedruleOnDemandOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return QuerySchedruleOnDemandOutcome(QuerySchedruleOnDemandResult(outcome.result()));
else
return QuerySchedruleOnDemandOutcome(outcome.error());
}
void DdosbgpClient::querySchedruleOnDemandAsync(const QuerySchedruleOnDemandRequest& request, const QuerySchedruleOnDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, querySchedruleOnDemand(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::QuerySchedruleOnDemandOutcomeCallable DdosbgpClient::querySchedruleOnDemandCallable(const QuerySchedruleOnDemandRequest &request) const
{
auto task = std::make_shared<std::packaged_task<QuerySchedruleOnDemandOutcome()>>(
[this, request]()
{
return this->querySchedruleOnDemand(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::SetInstanceModeOnDemandOutcome DdosbgpClient::setInstanceModeOnDemand(const SetInstanceModeOnDemandRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SetInstanceModeOnDemandOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SetInstanceModeOnDemandOutcome(SetInstanceModeOnDemandResult(outcome.result()));
else
return SetInstanceModeOnDemandOutcome(outcome.error());
}
void DdosbgpClient::setInstanceModeOnDemandAsync(const SetInstanceModeOnDemandRequest& request, const SetInstanceModeOnDemandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, setInstanceModeOnDemand(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::SetInstanceModeOnDemandOutcomeCallable DdosbgpClient::setInstanceModeOnDemandCallable(const SetInstanceModeOnDemandRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SetInstanceModeOnDemandOutcome()>>(
[this, request]()
{
return this->setInstanceModeOnDemand(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::TagResourcesOutcome DdosbgpClient::tagResources(const TagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return TagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return TagResourcesOutcome(TagResourcesResult(outcome.result()));
else
return TagResourcesOutcome(outcome.error());
}
void DdosbgpClient::tagResourcesAsync(const TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, tagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::TagResourcesOutcomeCallable DdosbgpClient::tagResourcesCallable(const TagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<TagResourcesOutcome()>>(
[this, request]()
{
return this->tagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DdosbgpClient::UntagResourcesOutcome DdosbgpClient::untagResources(const UntagResourcesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UntagResourcesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UntagResourcesOutcome(UntagResourcesResult(outcome.result()));
else
return UntagResourcesOutcome(outcome.error());
}
void DdosbgpClient::untagResourcesAsync(const UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, untagResources(request), context);
};
asyncExecute(new Runnable(fn));
}
DdosbgpClient::UntagResourcesOutcomeCallable DdosbgpClient::untagResourcesCallable(const UntagResourcesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UntagResourcesOutcome()>>(
[this, request]()
{
return this->untagResources(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
Reference in New Issue View Git Blame Copy Permalink