2034 lines
72 KiB
C++
2034 lines
72 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/cas/CasClient.h>
|
|
#include <alibabacloud/core/SimpleCredentialsProvider.h>
|
|
|
|
using namespace AlibabaCloud;
|
|
using namespace AlibabaCloud::Location;
|
|
using namespace AlibabaCloud::Cas;
|
|
using namespace AlibabaCloud::Cas::Model;
|
|
|
|
namespace
|
|
{
|
|
const std::string SERVICE_NAME = "cas";
|
|
}
|
|
|
|
CasClient::CasClient(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, "cas");
|
|
}
|
|
|
|
CasClient::CasClient(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, "cas");
|
|
}
|
|
|
|
CasClient::CasClient(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, "cas");
|
|
}
|
|
|
|
CasClient::~CasClient()
|
|
{}
|
|
|
|
CasClient::CreateAliDnsRecordIdOutcome CasClient::createAliDnsRecordId(const CreateAliDnsRecordIdRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateAliDnsRecordIdOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateAliDnsRecordIdOutcome(CreateAliDnsRecordIdResult(outcome.result()));
|
|
else
|
|
return CreateAliDnsRecordIdOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createAliDnsRecordIdAsync(const CreateAliDnsRecordIdRequest& request, const CreateAliDnsRecordIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createAliDnsRecordId(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateAliDnsRecordIdOutcomeCallable CasClient::createAliDnsRecordIdCallable(const CreateAliDnsRecordIdRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateAliDnsRecordIdOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createAliDnsRecordId(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateCertificateOutcome CasClient::createCertificate(const CreateCertificateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateCertificateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateCertificateOutcome(CreateCertificateResult(outcome.result()));
|
|
else
|
|
return CreateCertificateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createCertificateAsync(const CreateCertificateRequest& request, const CreateCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createCertificate(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateCertificateOutcomeCallable CasClient::createCertificateCallable(const CreateCertificateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateCertificateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createCertificate(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateCertificateNameOutcome CasClient::createCertificateName(const CreateCertificateNameRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateCertificateNameOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateCertificateNameOutcome(CreateCertificateNameResult(outcome.result()));
|
|
else
|
|
return CreateCertificateNameOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createCertificateNameAsync(const CreateCertificateNameRequest& request, const CreateCertificateNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createCertificateName(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateCertificateNameOutcomeCallable CasClient::createCertificateNameCallable(const CreateCertificateNameRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateCertificateNameOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createCertificateName(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateCooperationOrderOutcome CasClient::createCooperationOrder(const CreateCooperationOrderRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateCooperationOrderOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateCooperationOrderOutcome(CreateCooperationOrderResult(outcome.result()));
|
|
else
|
|
return CreateCooperationOrderOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createCooperationOrderAsync(const CreateCooperationOrderRequest& request, const CreateCooperationOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createCooperationOrder(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateCooperationOrderOutcomeCallable CasClient::createCooperationOrderCallable(const CreateCooperationOrderRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateCooperationOrderOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createCooperationOrder(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateDeploymentOutcome CasClient::createDeployment(const CreateDeploymentRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateDeploymentOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateDeploymentOutcome(CreateDeploymentResult(outcome.result()));
|
|
else
|
|
return CreateDeploymentOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createDeploymentAsync(const CreateDeploymentRequest& request, const CreateDeploymentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createDeployment(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateDeploymentOutcomeCallable CasClient::createDeploymentCallable(const CreateDeploymentRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateDeploymentOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createDeployment(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateDomainVerifyConfigurationStatusOutcome CasClient::createDomainVerifyConfigurationStatus(const CreateDomainVerifyConfigurationStatusRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateDomainVerifyConfigurationStatusOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateDomainVerifyConfigurationStatusOutcome(CreateDomainVerifyConfigurationStatusResult(outcome.result()));
|
|
else
|
|
return CreateDomainVerifyConfigurationStatusOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createDomainVerifyConfigurationStatusAsync(const CreateDomainVerifyConfigurationStatusRequest& request, const CreateDomainVerifyConfigurationStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createDomainVerifyConfigurationStatus(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateDomainVerifyConfigurationStatusOutcomeCallable CasClient::createDomainVerifyConfigurationStatusCallable(const CreateDomainVerifyConfigurationStatusRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateDomainVerifyConfigurationStatusOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createDomainVerifyConfigurationStatus(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateFilingSignatureDocumentOutcome CasClient::createFilingSignatureDocument(const CreateFilingSignatureDocumentRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateFilingSignatureDocumentOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateFilingSignatureDocumentOutcome(CreateFilingSignatureDocumentResult(outcome.result()));
|
|
else
|
|
return CreateFilingSignatureDocumentOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createFilingSignatureDocumentAsync(const CreateFilingSignatureDocumentRequest& request, const CreateFilingSignatureDocumentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createFilingSignatureDocument(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateFilingSignatureDocumentOutcomeCallable CasClient::createFilingSignatureDocumentCallable(const CreateFilingSignatureDocumentRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateFilingSignatureDocumentOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createFilingSignatureDocument(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateOrderAuditOutcome CasClient::createOrderAudit(const CreateOrderAuditRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateOrderAuditOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateOrderAuditOutcome(CreateOrderAuditResult(outcome.result()));
|
|
else
|
|
return CreateOrderAuditOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createOrderAuditAsync(const CreateOrderAuditRequest& request, const CreateOrderAuditAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createOrderAudit(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateOrderAuditOutcomeCallable CasClient::createOrderAuditCallable(const CreateOrderAuditRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateOrderAuditOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createOrderAudit(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateOrderCancelOutcome CasClient::createOrderCancel(const CreateOrderCancelRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateOrderCancelOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateOrderCancelOutcome(CreateOrderCancelResult(outcome.result()));
|
|
else
|
|
return CreateOrderCancelOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createOrderCancelAsync(const CreateOrderCancelRequest& request, const CreateOrderCancelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createOrderCancel(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateOrderCancelOutcomeCallable CasClient::createOrderCancelCallable(const CreateOrderCancelRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateOrderCancelOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createOrderCancel(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateOrderDocumentOutcome CasClient::createOrderDocument(const CreateOrderDocumentRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateOrderDocumentOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateOrderDocumentOutcome(CreateOrderDocumentResult(outcome.result()));
|
|
else
|
|
return CreateOrderDocumentOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createOrderDocumentAsync(const CreateOrderDocumentRequest& request, const CreateOrderDocumentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createOrderDocument(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateOrderDocumentOutcomeCallable CasClient::createOrderDocumentCallable(const CreateOrderDocumentRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateOrderDocumentOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createOrderDocument(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateOrderMaterialOutcome CasClient::createOrderMaterial(const CreateOrderMaterialRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateOrderMaterialOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateOrderMaterialOutcome(CreateOrderMaterialResult(outcome.result()));
|
|
else
|
|
return CreateOrderMaterialOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createOrderMaterialAsync(const CreateOrderMaterialRequest& request, const CreateOrderMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createOrderMaterial(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateOrderMaterialOutcomeCallable CasClient::createOrderMaterialCallable(const CreateOrderMaterialRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateOrderMaterialOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createOrderMaterial(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateOrderRefundRecordOutcome CasClient::createOrderRefundRecord(const CreateOrderRefundRecordRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateOrderRefundRecordOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateOrderRefundRecordOutcome(CreateOrderRefundRecordResult(outcome.result()));
|
|
else
|
|
return CreateOrderRefundRecordOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createOrderRefundRecordAsync(const CreateOrderRefundRecordRequest& request, const CreateOrderRefundRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createOrderRefundRecord(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateOrderRefundRecordOutcomeCallable CasClient::createOrderRefundRecordCallable(const CreateOrderRefundRecordRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateOrderRefundRecordOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createOrderRefundRecord(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateOrderRevokeOutcome CasClient::createOrderRevoke(const CreateOrderRevokeRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateOrderRevokeOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateOrderRevokeOutcome(CreateOrderRevokeResult(outcome.result()));
|
|
else
|
|
return CreateOrderRevokeOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createOrderRevokeAsync(const CreateOrderRevokeRequest& request, const CreateOrderRevokeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createOrderRevoke(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateOrderRevokeOutcomeCallable CasClient::createOrderRevokeCallable(const CreateOrderRevokeRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateOrderRevokeOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createOrderRevoke(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateSignatureOutcome CasClient::createSignature(const CreateSignatureRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateSignatureOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateSignatureOutcome(CreateSignatureResult(outcome.result()));
|
|
else
|
|
return CreateSignatureOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createSignatureAsync(const CreateSignatureRequest& request, const CreateSignatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createSignature(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateSignatureOutcomeCallable CasClient::createSignatureCallable(const CreateSignatureRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateSignatureOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createSignature(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateSignatureDocumentOutcome CasClient::createSignatureDocument(const CreateSignatureDocumentRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateSignatureDocumentOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateSignatureDocumentOutcome(CreateSignatureDocumentResult(outcome.result()));
|
|
else
|
|
return CreateSignatureDocumentOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createSignatureDocumentAsync(const CreateSignatureDocumentRequest& request, const CreateSignatureDocumentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createSignatureDocument(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateSignatureDocumentOutcomeCallable CasClient::createSignatureDocumentCallable(const CreateSignatureDocumentRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateSignatureDocumentOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createSignatureDocument(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateSignaturePeopleCertificateOutcome CasClient::createSignaturePeopleCertificate(const CreateSignaturePeopleCertificateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateSignaturePeopleCertificateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateSignaturePeopleCertificateOutcome(CreateSignaturePeopleCertificateResult(outcome.result()));
|
|
else
|
|
return CreateSignaturePeopleCertificateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createSignaturePeopleCertificateAsync(const CreateSignaturePeopleCertificateRequest& request, const CreateSignaturePeopleCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createSignaturePeopleCertificate(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateSignaturePeopleCertificateOutcomeCallable CasClient::createSignaturePeopleCertificateCallable(const CreateSignaturePeopleCertificateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateSignaturePeopleCertificateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createSignaturePeopleCertificate(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateUnDeploymentOutcome CasClient::createUnDeployment(const CreateUnDeploymentRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateUnDeploymentOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateUnDeploymentOutcome(CreateUnDeploymentResult(outcome.result()));
|
|
else
|
|
return CreateUnDeploymentOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createUnDeploymentAsync(const CreateUnDeploymentRequest& request, const CreateUnDeploymentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createUnDeployment(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateUnDeploymentOutcomeCallable CasClient::createUnDeploymentCallable(const CreateUnDeploymentRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateUnDeploymentOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createUnDeployment(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::CreateWebSignatureOutcome CasClient::createWebSignature(const CreateWebSignatureRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return CreateWebSignatureOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return CreateWebSignatureOutcome(CreateWebSignatureResult(outcome.result()));
|
|
else
|
|
return CreateWebSignatureOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::createWebSignatureAsync(const CreateWebSignatureRequest& request, const CreateWebSignatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, createWebSignature(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::CreateWebSignatureOutcomeCallable CasClient::createWebSignatureCallable(const CreateWebSignatureRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<CreateWebSignatureOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->createWebSignature(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DeleteCertificateOutcome CasClient::deleteCertificate(const DeleteCertificateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteCertificateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteCertificateOutcome(DeleteCertificateResult(outcome.result()));
|
|
else
|
|
return DeleteCertificateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::deleteCertificateAsync(const DeleteCertificateRequest& request, const DeleteCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteCertificate(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DeleteCertificateOutcomeCallable CasClient::deleteCertificateCallable(const DeleteCertificateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteCertificateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteCertificate(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DeleteOrderOutcome CasClient::deleteOrder(const DeleteOrderRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DeleteOrderOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DeleteOrderOutcome(DeleteOrderResult(outcome.result()));
|
|
else
|
|
return DeleteOrderOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::deleteOrderAsync(const DeleteOrderRequest& request, const DeleteOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, deleteOrder(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DeleteOrderOutcomeCallable CasClient::deleteOrderCallable(const DeleteOrderRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DeleteOrderOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->deleteOrder(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeCertificateBrandListOutcome CasClient::describeCertificateBrandList(const DescribeCertificateBrandListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeCertificateBrandListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeCertificateBrandListOutcome(DescribeCertificateBrandListResult(outcome.result()));
|
|
else
|
|
return DescribeCertificateBrandListOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeCertificateBrandListAsync(const DescribeCertificateBrandListRequest& request, const DescribeCertificateBrandListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeCertificateBrandList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeCertificateBrandListOutcomeCallable CasClient::describeCertificateBrandListCallable(const DescribeCertificateBrandListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeCertificateBrandListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeCertificateBrandList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeCertificateDetailOutcome CasClient::describeCertificateDetail(const DescribeCertificateDetailRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeCertificateDetailOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeCertificateDetailOutcome(DescribeCertificateDetailResult(outcome.result()));
|
|
else
|
|
return DescribeCertificateDetailOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeCertificateDetailAsync(const DescribeCertificateDetailRequest& request, const DescribeCertificateDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeCertificateDetail(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeCertificateDetailOutcomeCallable CasClient::describeCertificateDetailCallable(const DescribeCertificateDetailRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeCertificateDetailOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeCertificateDetail(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeCertificateListOutcome CasClient::describeCertificateList(const DescribeCertificateListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeCertificateListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeCertificateListOutcome(DescribeCertificateListResult(outcome.result()));
|
|
else
|
|
return DescribeCertificateListOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeCertificateListAsync(const DescribeCertificateListRequest& request, const DescribeCertificateListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeCertificateList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeCertificateListOutcomeCallable CasClient::describeCertificateListCallable(const DescribeCertificateListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeCertificateListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeCertificateList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeCertificateStatusCountOutcome CasClient::describeCertificateStatusCount(const DescribeCertificateStatusCountRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeCertificateStatusCountOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeCertificateStatusCountOutcome(DescribeCertificateStatusCountResult(outcome.result()));
|
|
else
|
|
return DescribeCertificateStatusCountOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeCertificateStatusCountAsync(const DescribeCertificateStatusCountRequest& request, const DescribeCertificateStatusCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeCertificateStatusCount(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeCertificateStatusCountOutcomeCallable CasClient::describeCertificateStatusCountCallable(const DescribeCertificateStatusCountRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeCertificateStatusCountOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeCertificateStatusCount(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeDeploymentDetailOutcome CasClient::describeDeploymentDetail(const DescribeDeploymentDetailRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDeploymentDetailOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDeploymentDetailOutcome(DescribeDeploymentDetailResult(outcome.result()));
|
|
else
|
|
return DescribeDeploymentDetailOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeDeploymentDetailAsync(const DescribeDeploymentDetailRequest& request, const DescribeDeploymentDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDeploymentDetail(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeDeploymentDetailOutcomeCallable CasClient::describeDeploymentDetailCallable(const DescribeDeploymentDetailRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDeploymentDetailOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDeploymentDetail(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeDeploymentDomainListOutcome CasClient::describeDeploymentDomainList(const DescribeDeploymentDomainListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDeploymentDomainListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDeploymentDomainListOutcome(DescribeDeploymentDomainListResult(outcome.result()));
|
|
else
|
|
return DescribeDeploymentDomainListOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeDeploymentDomainListAsync(const DescribeDeploymentDomainListRequest& request, const DescribeDeploymentDomainListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDeploymentDomainList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeDeploymentDomainListOutcomeCallable CasClient::describeDeploymentDomainListCallable(const DescribeDeploymentDomainListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDeploymentDomainListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDeploymentDomainList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeDeploymentProductOutcome CasClient::describeDeploymentProduct(const DescribeDeploymentProductRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDeploymentProductOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDeploymentProductOutcome(DescribeDeploymentProductResult(outcome.result()));
|
|
else
|
|
return DescribeDeploymentProductOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeDeploymentProductAsync(const DescribeDeploymentProductRequest& request, const DescribeDeploymentProductAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDeploymentProduct(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeDeploymentProductOutcomeCallable CasClient::describeDeploymentProductCallable(const DescribeDeploymentProductRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDeploymentProductOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDeploymentProduct(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeDeploymentRegionListOutcome CasClient::describeDeploymentRegionList(const DescribeDeploymentRegionListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDeploymentRegionListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDeploymentRegionListOutcome(DescribeDeploymentRegionListResult(outcome.result()));
|
|
else
|
|
return DescribeDeploymentRegionListOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeDeploymentRegionListAsync(const DescribeDeploymentRegionListRequest& request, const DescribeDeploymentRegionListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDeploymentRegionList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeDeploymentRegionListOutcomeCallable CasClient::describeDeploymentRegionListCallable(const DescribeDeploymentRegionListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDeploymentRegionListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDeploymentRegionList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeDomainVerifyConfigurationStatusOutcome CasClient::describeDomainVerifyConfigurationStatus(const DescribeDomainVerifyConfigurationStatusRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDomainVerifyConfigurationStatusOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDomainVerifyConfigurationStatusOutcome(DescribeDomainVerifyConfigurationStatusResult(outcome.result()));
|
|
else
|
|
return DescribeDomainVerifyConfigurationStatusOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeDomainVerifyConfigurationStatusAsync(const DescribeDomainVerifyConfigurationStatusRequest& request, const DescribeDomainVerifyConfigurationStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDomainVerifyConfigurationStatus(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeDomainVerifyConfigurationStatusOutcomeCallable CasClient::describeDomainVerifyConfigurationStatusCallable(const DescribeDomainVerifyConfigurationStatusRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDomainVerifyConfigurationStatusOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDomainVerifyConfigurationStatus(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeDomainVerifyInfoOutcome CasClient::describeDomainVerifyInfo(const DescribeDomainVerifyInfoRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDomainVerifyInfoOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDomainVerifyInfoOutcome(DescribeDomainVerifyInfoResult(outcome.result()));
|
|
else
|
|
return DescribeDomainVerifyInfoOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeDomainVerifyInfoAsync(const DescribeDomainVerifyInfoRequest& request, const DescribeDomainVerifyInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDomainVerifyInfo(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeDomainVerifyInfoOutcomeCallable CasClient::describeDomainVerifyInfoCallable(const DescribeDomainVerifyInfoRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDomainVerifyInfoOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDomainVerifyInfo(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeDownloadCertificateOutcome CasClient::describeDownloadCertificate(const DescribeDownloadCertificateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDownloadCertificateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDownloadCertificateOutcome(DescribeDownloadCertificateResult(outcome.result()));
|
|
else
|
|
return DescribeDownloadCertificateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeDownloadCertificateAsync(const DescribeDownloadCertificateRequest& request, const DescribeDownloadCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDownloadCertificate(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeDownloadCertificateOutcomeCallable CasClient::describeDownloadCertificateCallable(const DescribeDownloadCertificateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDownloadCertificateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDownloadCertificate(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeDownloadDomainVerifyConfigurationOutcome CasClient::describeDownloadDomainVerifyConfiguration(const DescribeDownloadDomainVerifyConfigurationRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeDownloadDomainVerifyConfigurationOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeDownloadDomainVerifyConfigurationOutcome(DescribeDownloadDomainVerifyConfigurationResult(outcome.result()));
|
|
else
|
|
return DescribeDownloadDomainVerifyConfigurationOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeDownloadDomainVerifyConfigurationAsync(const DescribeDownloadDomainVerifyConfigurationRequest& request, const DescribeDownloadDomainVerifyConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeDownloadDomainVerifyConfiguration(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeDownloadDomainVerifyConfigurationOutcomeCallable CasClient::describeDownloadDomainVerifyConfigurationCallable(const DescribeDownloadDomainVerifyConfigurationRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeDownloadDomainVerifyConfigurationOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeDownloadDomainVerifyConfiguration(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeExpectationResultOutcome CasClient::describeExpectationResult(const DescribeExpectationResultRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeExpectationResultOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeExpectationResultOutcome(DescribeExpectationResultResult(outcome.result()));
|
|
else
|
|
return DescribeExpectationResultOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeExpectationResultAsync(const DescribeExpectationResultRequest& request, const DescribeExpectationResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeExpectationResult(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeExpectationResultOutcomeCallable CasClient::describeExpectationResultCallable(const DescribeExpectationResultRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeExpectationResultOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeExpectationResult(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeHelpListOutcome CasClient::describeHelpList(const DescribeHelpListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeHelpListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeHelpListOutcome(DescribeHelpListResult(outcome.result()));
|
|
else
|
|
return DescribeHelpListOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeHelpListAsync(const DescribeHelpListRequest& request, const DescribeHelpListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeHelpList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeHelpListOutcomeCallable CasClient::describeHelpListCallable(const DescribeHelpListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeHelpListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeHelpList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeLocationListOutcome CasClient::describeLocationList(const DescribeLocationListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeLocationListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeLocationListOutcome(DescribeLocationListResult(outcome.result()));
|
|
else
|
|
return DescribeLocationListOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeLocationListAsync(const DescribeLocationListRequest& request, const DescribeLocationListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeLocationList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeLocationListOutcomeCallable CasClient::describeLocationListCallable(const DescribeLocationListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeLocationListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeLocationList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeOSSDownloadInfoOutcome CasClient::describeOSSDownloadInfo(const DescribeOSSDownloadInfoRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOSSDownloadInfoOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOSSDownloadInfoOutcome(DescribeOSSDownloadInfoResult(outcome.result()));
|
|
else
|
|
return DescribeOSSDownloadInfoOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeOSSDownloadInfoAsync(const DescribeOSSDownloadInfoRequest& request, const DescribeOSSDownloadInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOSSDownloadInfo(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeOSSDownloadInfoOutcomeCallable CasClient::describeOSSDownloadInfoCallable(const DescribeOSSDownloadInfoRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOSSDownloadInfoOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOSSDownloadInfo(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeOSSUploadInfoOutcome CasClient::describeOSSUploadInfo(const DescribeOSSUploadInfoRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOSSUploadInfoOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOSSUploadInfoOutcome(DescribeOSSUploadInfoResult(outcome.result()));
|
|
else
|
|
return DescribeOSSUploadInfoOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeOSSUploadInfoAsync(const DescribeOSSUploadInfoRequest& request, const DescribeOSSUploadInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOSSUploadInfo(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeOSSUploadInfoOutcomeCallable CasClient::describeOSSUploadInfoCallable(const DescribeOSSUploadInfoRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOSSUploadInfoOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOSSUploadInfo(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeOrderAuditFailRecordOutcome CasClient::describeOrderAuditFailRecord(const DescribeOrderAuditFailRecordRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOrderAuditFailRecordOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOrderAuditFailRecordOutcome(DescribeOrderAuditFailRecordResult(outcome.result()));
|
|
else
|
|
return DescribeOrderAuditFailRecordOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeOrderAuditFailRecordAsync(const DescribeOrderAuditFailRecordRequest& request, const DescribeOrderAuditFailRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOrderAuditFailRecord(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeOrderAuditFailRecordOutcomeCallable CasClient::describeOrderAuditFailRecordCallable(const DescribeOrderAuditFailRecordRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOrderAuditFailRecordOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOrderAuditFailRecord(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeOrderCountForConsoleIndexOutcome CasClient::describeOrderCountForConsoleIndex(const DescribeOrderCountForConsoleIndexRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOrderCountForConsoleIndexOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOrderCountForConsoleIndexOutcome(DescribeOrderCountForConsoleIndexResult(outcome.result()));
|
|
else
|
|
return DescribeOrderCountForConsoleIndexOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeOrderCountForConsoleIndexAsync(const DescribeOrderCountForConsoleIndexRequest& request, const DescribeOrderCountForConsoleIndexAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOrderCountForConsoleIndex(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeOrderCountForConsoleIndexOutcomeCallable CasClient::describeOrderCountForConsoleIndexCallable(const DescribeOrderCountForConsoleIndexRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOrderCountForConsoleIndexOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOrderCountForConsoleIndex(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeOrderDetailOutcome CasClient::describeOrderDetail(const DescribeOrderDetailRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOrderDetailOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOrderDetailOutcome(DescribeOrderDetailResult(outcome.result()));
|
|
else
|
|
return DescribeOrderDetailOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeOrderDetailAsync(const DescribeOrderDetailRequest& request, const DescribeOrderDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOrderDetail(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeOrderDetailOutcomeCallable CasClient::describeOrderDetailCallable(const DescribeOrderDetailRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOrderDetailOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOrderDetail(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeOrderDocumentOutcome CasClient::describeOrderDocument(const DescribeOrderDocumentRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOrderDocumentOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOrderDocumentOutcome(DescribeOrderDocumentResult(outcome.result()));
|
|
else
|
|
return DescribeOrderDocumentOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeOrderDocumentAsync(const DescribeOrderDocumentRequest& request, const DescribeOrderDocumentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOrderDocument(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeOrderDocumentOutcomeCallable CasClient::describeOrderDocumentCallable(const DescribeOrderDocumentRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOrderDocumentOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOrderDocument(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeOrderListOutcome CasClient::describeOrderList(const DescribeOrderListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOrderListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOrderListOutcome(DescribeOrderListResult(outcome.result()));
|
|
else
|
|
return DescribeOrderListOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeOrderListAsync(const DescribeOrderListRequest& request, const DescribeOrderListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOrderList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeOrderListOutcomeCallable CasClient::describeOrderListCallable(const DescribeOrderListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOrderListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOrderList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeOrderMaterialOutcome CasClient::describeOrderMaterial(const DescribeOrderMaterialRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOrderMaterialOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOrderMaterialOutcome(DescribeOrderMaterialResult(outcome.result()));
|
|
else
|
|
return DescribeOrderMaterialOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeOrderMaterialAsync(const DescribeOrderMaterialRequest& request, const DescribeOrderMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOrderMaterial(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeOrderMaterialOutcomeCallable CasClient::describeOrderMaterialCallable(const DescribeOrderMaterialRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOrderMaterialOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOrderMaterial(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeOrderRefundRecordOutcome CasClient::describeOrderRefundRecord(const DescribeOrderRefundRecordRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeOrderRefundRecordOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeOrderRefundRecordOutcome(DescribeOrderRefundRecordResult(outcome.result()));
|
|
else
|
|
return DescribeOrderRefundRecordOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeOrderRefundRecordAsync(const DescribeOrderRefundRecordRequest& request, const DescribeOrderRefundRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeOrderRefundRecord(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeOrderRefundRecordOutcomeCallable CasClient::describeOrderRefundRecordCallable(const DescribeOrderRefundRecordRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeOrderRefundRecordOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeOrderRefundRecord(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeRenewOrderOutcome CasClient::describeRenewOrder(const DescribeRenewOrderRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeRenewOrderOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeRenewOrderOutcome(DescribeRenewOrderResult(outcome.result()));
|
|
else
|
|
return DescribeRenewOrderOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeRenewOrderAsync(const DescribeRenewOrderRequest& request, const DescribeRenewOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeRenewOrder(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeRenewOrderOutcomeCallable CasClient::describeRenewOrderCallable(const DescribeRenewOrderRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeRenewOrderOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeRenewOrder(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeSignatureCapacityOutcome CasClient::describeSignatureCapacity(const DescribeSignatureCapacityRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeSignatureCapacityOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeSignatureCapacityOutcome(DescribeSignatureCapacityResult(outcome.result()));
|
|
else
|
|
return DescribeSignatureCapacityOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeSignatureCapacityAsync(const DescribeSignatureCapacityRequest& request, const DescribeSignatureCapacityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeSignatureCapacity(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeSignatureCapacityOutcomeCallable CasClient::describeSignatureCapacityCallable(const DescribeSignatureCapacityRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeSignatureCapacityOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeSignatureCapacity(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeSignatureProductStateOutcome CasClient::describeSignatureProductState(const DescribeSignatureProductStateRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeSignatureProductStateOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeSignatureProductStateOutcome(DescribeSignatureProductStateResult(outcome.result()));
|
|
else
|
|
return DescribeSignatureProductStateOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeSignatureProductStateAsync(const DescribeSignatureProductStateRequest& request, const DescribeSignatureProductStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeSignatureProductState(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeSignatureProductStateOutcomeCallable CasClient::describeSignatureProductStateCallable(const DescribeSignatureProductStateRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeSignatureProductStateOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeSignatureProductState(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeSignatureStatisticsOutcome CasClient::describeSignatureStatistics(const DescribeSignatureStatisticsRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeSignatureStatisticsOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeSignatureStatisticsOutcome(DescribeSignatureStatisticsResult(outcome.result()));
|
|
else
|
|
return DescribeSignatureStatisticsOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeSignatureStatisticsAsync(const DescribeSignatureStatisticsRequest& request, const DescribeSignatureStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeSignatureStatistics(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeSignatureStatisticsOutcomeCallable CasClient::describeSignatureStatisticsCallable(const DescribeSignatureStatisticsRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeSignatureStatisticsOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeSignatureStatistics(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeSignatureTradeDetailOutcome CasClient::describeSignatureTradeDetail(const DescribeSignatureTradeDetailRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeSignatureTradeDetailOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeSignatureTradeDetailOutcome(DescribeSignatureTradeDetailResult(outcome.result()));
|
|
else
|
|
return DescribeSignatureTradeDetailOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeSignatureTradeDetailAsync(const DescribeSignatureTradeDetailRequest& request, const DescribeSignatureTradeDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeSignatureTradeDetail(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeSignatureTradeDetailOutcomeCallable CasClient::describeSignatureTradeDetailCallable(const DescribeSignatureTradeDetailRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeSignatureTradeDetailOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeSignatureTradeDetail(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeSignatureTradeListOutcome CasClient::describeSignatureTradeList(const DescribeSignatureTradeListRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeSignatureTradeListOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeSignatureTradeListOutcome(DescribeSignatureTradeListResult(outcome.result()));
|
|
else
|
|
return DescribeSignatureTradeListOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeSignatureTradeListAsync(const DescribeSignatureTradeListRequest& request, const DescribeSignatureTradeListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeSignatureTradeList(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeSignatureTradeListOutcomeCallable CasClient::describeSignatureTradeListCallable(const DescribeSignatureTradeListRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeSignatureTradeListOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeSignatureTradeList(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::DescribeStsAuthStatusOutcome CasClient::describeStsAuthStatus(const DescribeStsAuthStatusRequest &request) const
|
|
{
|
|
auto endpointOutcome = endpointProvider_->getEndpoint();
|
|
if (!endpointOutcome.isSuccess())
|
|
return DescribeStsAuthStatusOutcome(endpointOutcome.error());
|
|
|
|
auto outcome = makeRequest(endpointOutcome.result(), request);
|
|
|
|
if (outcome.isSuccess())
|
|
return DescribeStsAuthStatusOutcome(DescribeStsAuthStatusResult(outcome.result()));
|
|
else
|
|
return DescribeStsAuthStatusOutcome(outcome.error());
|
|
}
|
|
|
|
void CasClient::describeStsAuthStatusAsync(const DescribeStsAuthStatusRequest& request, const DescribeStsAuthStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
|
|
{
|
|
auto fn = [this, request, handler, context]()
|
|
{
|
|
handler(this, request, describeStsAuthStatus(request), context);
|
|
};
|
|
|
|
asyncExecute(new Runnable(fn));
|
|
}
|
|
|
|
CasClient::DescribeStsAuthStatusOutcomeCallable CasClient::describeStsAuthStatusCallable(const DescribeStsAuthStatusRequest &request) const
|
|
{
|
|
auto task = std::make_shared<std::packaged_task<DescribeStsAuthStatusOutcome()>>(
|
|
[this, request]()
|
|
{
|
|
return this->describeStsAuthStatus(request);
|
|
});
|
|
|
|
asyncExecute(new Runnable([task]() { (*task)(); }));
|
|
return task->get_future();
|
|
}
|
|
|
|
CasClient::ListTagKeysOutcome CasClient::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 CasClient::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));
|
|
}
|
|
|
|
CasClient::ListTagKeysOutcomeCallable CasClient::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();
|
|
}
|
|
|
|
CasClient::ListTagResourcesOutcome CasClient::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 CasClient::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));
|
|
}
|
|
|
|
CasClient::ListTagResourcesOutcomeCallable CasClient::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();
|
|
}
|
|
|
|
CasClient::TagResourcesOutcome CasClient::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 CasClient::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));
|
|
}
|
|
|
|
CasClient::TagResourcesOutcomeCallable CasClient::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();
|
|
}
|
|
|
|
CasClient::UntagResourcesOutcome CasClient::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 CasClient::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));
|
|
}
|
|
|
|
CasClient::UntagResourcesOutcomeCallable CasClient::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();
|
|
}
|
|
|