558 lines
20 KiB
C++
558 lines
20 KiB
C++
/*
|
|
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <alibabacloud/beian/BeianClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::Beian;
|
|
using namespace AlibabaCloud::Beian::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "Beian";
|
|
}
|
|
|
|
BeianClient::BeianClient(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, "");
|
|
}
|
|
|
|
BeianClient::BeianClient(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, "");
|
|
}
|
|
|
|
BeianClient::BeianClient(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, "");
|
|
}
|
|
|
|
BeianClient::~BeianClient()
|
|
{}
|
|
|
|
BeianClient::DeleteUnbeianIpCheckTypeOutcome BeianClient::deleteUnbeianIpCheckType(const DeleteUnbeianIpCheckTypeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteUnbeianIpCheckTypeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteUnbeianIpCheckTypeOutcome(DeleteUnbeianIpCheckTypeResult(outcome.result()));
|
|
else
|
|
return DeleteUnbeianIpCheckTypeOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::deleteUnbeianIpCheckTypeAsync(const DeleteUnbeianIpCheckTypeRequest& request, const DeleteUnbeianIpCheckTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteUnbeianIpCheckType(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::DeleteUnbeianIpCheckTypeOutcomeCallable BeianClient::deleteUnbeianIpCheckTypeCallable(const DeleteUnbeianIpCheckTypeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteUnbeianIpCheckTypeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteUnbeianIpCheckType(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::GetMainDomainOutcome BeianClient::getMainDomain(const GetMainDomainRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return GetMainDomainOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return GetMainDomainOutcome(GetMainDomainResult(outcome.result()));
|
|
else
|
|
return GetMainDomainOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::getMainDomainAsync(const GetMainDomainRequest& request, const GetMainDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, getMainDomain(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::GetMainDomainOutcomeCallable BeianClient::getMainDomainCallable(const GetMainDomainRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<GetMainDomainOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->getMainDomain(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::InsertUnbeianIpCheckTypeOutcome BeianClient::insertUnbeianIpCheckType(const InsertUnbeianIpCheckTypeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return InsertUnbeianIpCheckTypeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return InsertUnbeianIpCheckTypeOutcome(InsertUnbeianIpCheckTypeResult(outcome.result()));
|
|
else
|
|
return InsertUnbeianIpCheckTypeOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::insertUnbeianIpCheckTypeAsync(const InsertUnbeianIpCheckTypeRequest& request, const InsertUnbeianIpCheckTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, insertUnbeianIpCheckType(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::InsertUnbeianIpCheckTypeOutcomeCallable BeianClient::insertUnbeianIpCheckTypeCallable(const InsertUnbeianIpCheckTypeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<InsertUnbeianIpCheckTypeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->insertUnbeianIpCheckType(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::ListUnbeianIpCheckTypeOutcome BeianClient::listUnbeianIpCheckType(const ListUnbeianIpCheckTypeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ListUnbeianIpCheckTypeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ListUnbeianIpCheckTypeOutcome(ListUnbeianIpCheckTypeResult(outcome.result()));
|
|
else
|
|
return ListUnbeianIpCheckTypeOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::listUnbeianIpCheckTypeAsync(const ListUnbeianIpCheckTypeRequest& request, const ListUnbeianIpCheckTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, listUnbeianIpCheckType(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::ListUnbeianIpCheckTypeOutcomeCallable BeianClient::listUnbeianIpCheckTypeCallable(const ListUnbeianIpCheckTypeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ListUnbeianIpCheckTypeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->listUnbeianIpCheckType(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::ManageAccessorDomainOutcome BeianClient::manageAccessorDomain(const ManageAccessorDomainRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ManageAccessorDomainOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ManageAccessorDomainOutcome(ManageAccessorDomainResult(outcome.result()));
|
|
else
|
|
return ManageAccessorDomainOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::manageAccessorDomainAsync(const ManageAccessorDomainRequest& request, const ManageAccessorDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, manageAccessorDomain(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::ManageAccessorDomainOutcomeCallable BeianClient::manageAccessorDomainCallable(const ManageAccessorDomainRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ManageAccessorDomainOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->manageAccessorDomain(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::ManageAccessorDomainWhiteListOutcome BeianClient::manageAccessorDomainWhiteList(const ManageAccessorDomainWhiteListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ManageAccessorDomainWhiteListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ManageAccessorDomainWhiteListOutcome(ManageAccessorDomainWhiteListResult(outcome.result()));
|
|
else
|
|
return ManageAccessorDomainWhiteListOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::manageAccessorDomainWhiteListAsync(const ManageAccessorDomainWhiteListRequest& request, const ManageAccessorDomainWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, manageAccessorDomainWhiteList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::ManageAccessorDomainWhiteListOutcomeCallable BeianClient::manageAccessorDomainWhiteListCallable(const ManageAccessorDomainWhiteListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ManageAccessorDomainWhiteListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->manageAccessorDomainWhiteList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::ManageAccessorIpOutcome BeianClient::manageAccessorIp(const ManageAccessorIpRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return ManageAccessorIpOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return ManageAccessorIpOutcome(ManageAccessorIpResult(outcome.result()));
|
|
else
|
|
return ManageAccessorIpOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::manageAccessorIpAsync(const ManageAccessorIpRequest& request, const ManageAccessorIpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, manageAccessorIp(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::ManageAccessorIpOutcomeCallable BeianClient::manageAccessorIpCallable(const ManageAccessorIpRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<ManageAccessorIpOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->manageAccessorIp(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainOutcome BeianClient::queryAccessorDomain(const QueryAccessorDomainRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return QueryAccessorDomainOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return QueryAccessorDomainOutcome(QueryAccessorDomainResult(outcome.result()));
|
|
else
|
|
return QueryAccessorDomainOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::queryAccessorDomainAsync(const QueryAccessorDomainRequest& request, const QueryAccessorDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, queryAccessorDomain(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainOutcomeCallable BeianClient::queryAccessorDomainCallable(const QueryAccessorDomainRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<QueryAccessorDomainOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->queryAccessorDomain(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainListOutcome BeianClient::queryAccessorDomainList(const QueryAccessorDomainListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return QueryAccessorDomainListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return QueryAccessorDomainListOutcome(QueryAccessorDomainListResult(outcome.result()));
|
|
else
|
|
return QueryAccessorDomainListOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::queryAccessorDomainListAsync(const QueryAccessorDomainListRequest& request, const QueryAccessorDomainListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, queryAccessorDomainList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainListOutcomeCallable BeianClient::queryAccessorDomainListCallable(const QueryAccessorDomainListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<QueryAccessorDomainListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->queryAccessorDomainList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainStatusOutcome BeianClient::queryAccessorDomainStatus(const QueryAccessorDomainStatusRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return QueryAccessorDomainStatusOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return QueryAccessorDomainStatusOutcome(QueryAccessorDomainStatusResult(outcome.result()));
|
|
else
|
|
return QueryAccessorDomainStatusOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::queryAccessorDomainStatusAsync(const QueryAccessorDomainStatusRequest& request, const QueryAccessorDomainStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, queryAccessorDomainStatus(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainStatusOutcomeCallable BeianClient::queryAccessorDomainStatusCallable(const QueryAccessorDomainStatusRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<QueryAccessorDomainStatusOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->queryAccessorDomainStatus(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainWhiteListOutcome BeianClient::queryAccessorDomainWhiteList(const QueryAccessorDomainWhiteListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return QueryAccessorDomainWhiteListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return QueryAccessorDomainWhiteListOutcome(QueryAccessorDomainWhiteListResult(outcome.result()));
|
|
else
|
|
return QueryAccessorDomainWhiteListOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::queryAccessorDomainWhiteListAsync(const QueryAccessorDomainWhiteListRequest& request, const QueryAccessorDomainWhiteListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, queryAccessorDomainWhiteList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainWhiteListOutcomeCallable BeianClient::queryAccessorDomainWhiteListCallable(const QueryAccessorDomainWhiteListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<QueryAccessorDomainWhiteListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->queryAccessorDomainWhiteList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainsStatusOutcome BeianClient::queryAccessorDomainsStatus(const QueryAccessorDomainsStatusRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return QueryAccessorDomainsStatusOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return QueryAccessorDomainsStatusOutcome(QueryAccessorDomainsStatusResult(outcome.result()));
|
|
else
|
|
return QueryAccessorDomainsStatusOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::queryAccessorDomainsStatusAsync(const QueryAccessorDomainsStatusRequest& request, const QueryAccessorDomainsStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, queryAccessorDomainsStatus(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::QueryAccessorDomainsStatusOutcomeCallable BeianClient::queryAccessorDomainsStatusCallable(const QueryAccessorDomainsStatusRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<QueryAccessorDomainsStatusOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->queryAccessorDomainsStatus(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::QueryAccessorIpOutcome BeianClient::queryAccessorIp(const QueryAccessorIpRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return QueryAccessorIpOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return QueryAccessorIpOutcome(QueryAccessorIpResult(outcome.result()));
|
|
else
|
|
return QueryAccessorIpOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::queryAccessorIpAsync(const QueryAccessorIpRequest& request, const QueryAccessorIpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, queryAccessorIp(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::QueryAccessorIpOutcomeCallable BeianClient::queryAccessorIpCallable(const QueryAccessorIpRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<QueryAccessorIpOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->queryAccessorIp(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
BeianClient::SubmitAccessorFullDomainsOssListOutcome BeianClient::submitAccessorFullDomainsOssList(const SubmitAccessorFullDomainsOssListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return SubmitAccessorFullDomainsOssListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return SubmitAccessorFullDomainsOssListOutcome(SubmitAccessorFullDomainsOssListResult(outcome.result()));
|
|
else
|
|
return SubmitAccessorFullDomainsOssListOutcome(outcome.error());
|
|
}
|
|
|
|
void BeianClient::submitAccessorFullDomainsOssListAsync(const SubmitAccessorFullDomainsOssListRequest& request, const SubmitAccessorFullDomainsOssListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, submitAccessorFullDomainsOssList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
BeianClient::SubmitAccessorFullDomainsOssListOutcomeCallable BeianClient::submitAccessorFullDomainsOssListCallable(const SubmitAccessorFullDomainsOssListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<SubmitAccessorFullDomainsOssListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->submitAccessorFullDomainsOssList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|