ManagedBlockchainQueryClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/managedblockchain-query/ManagedBlockchainQueryPaginationBase.h>
#include <aws/managedblockchain-query/ManagedBlockchainQueryServiceClientModel.h>
#include <aws/managedblockchain-query/ManagedBlockchainQueryWaiter.h>
#include <aws/managedblockchain-query/ManagedBlockchainQuery_EXPORTS.h>
 
namespace Aws {
namespace ManagedBlockchainQuery {
class AWS_MANAGEDBLOCKCHAINQUERY_API ManagedBlockchainQueryClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<ManagedBlockchainQueryClient>,
      public ManagedBlockchainQueryPaginationBase<ManagedBlockchainQueryClient>,
      public ManagedBlockchainQueryWaiter<ManagedBlockchainQueryClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ManagedBlockchainQueryClientConfiguration ClientConfigurationType;
  typedef ManagedBlockchainQueryEndpointProvider EndpointProviderType;
 
  ManagedBlockchainQueryClient(const Aws::ManagedBlockchainQuery::ManagedBlockchainQueryClientConfiguration& clientConfiguration =
                                   Aws::ManagedBlockchainQuery::ManagedBlockchainQueryClientConfiguration(),
                               std::shared_ptr<ManagedBlockchainQueryEndpointProviderBase> endpointProvider = nullptr);
 
  ManagedBlockchainQueryClient(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<ManagedBlockchainQueryEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::ManagedBlockchainQuery::ManagedBlockchainQueryClientConfiguration& clientConfiguration =
                                   Aws::ManagedBlockchainQuery::ManagedBlockchainQueryClientConfiguration());
 
  ManagedBlockchainQueryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<ManagedBlockchainQueryEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::ManagedBlockchainQuery::ManagedBlockchainQueryClientConfiguration& clientConfiguration =
                                   Aws::ManagedBlockchainQuery::ManagedBlockchainQueryClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ManagedBlockchainQueryClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ManagedBlockchainQueryClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ManagedBlockchainQueryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ManagedBlockchainQueryClient();
 
  virtual Model::BatchGetTokenBalanceOutcome BatchGetTokenBalance(const Model::BatchGetTokenBalanceRequest& request = {}) const;
 
  template <typename BatchGetTokenBalanceRequestT = Model::BatchGetTokenBalanceRequest>
  Model::BatchGetTokenBalanceOutcomeCallable BatchGetTokenBalanceCallable(const BatchGetTokenBalanceRequestT& request = {}) const {
    return SubmitCallable(&ManagedBlockchainQueryClient::BatchGetTokenBalance, request);
  }
 
  template <typename BatchGetTokenBalanceRequestT = Model::BatchGetTokenBalanceRequest>
  void BatchGetTokenBalanceAsync(const BatchGetTokenBalanceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const BatchGetTokenBalanceRequestT& request = {}) const {
    return SubmitAsync(&ManagedBlockchainQueryClient::BatchGetTokenBalance, request, handler, context);
  }
 
  virtual Model::GetAssetContractOutcome GetAssetContract(const Model::GetAssetContractRequest& request) const;
 
  template <typename GetAssetContractRequestT = Model::GetAssetContractRequest>
  Model::GetAssetContractOutcomeCallable GetAssetContractCallable(const GetAssetContractRequestT& request) const {
    return SubmitCallable(&ManagedBlockchainQueryClient::GetAssetContract, request);
  }
 
  template <typename GetAssetContractRequestT = Model::GetAssetContractRequest>
  void GetAssetContractAsync(const GetAssetContractRequestT& request, const GetAssetContractResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedBlockchainQueryClient::GetAssetContract, request, handler, context);
  }
 
  virtual Model::GetTokenBalanceOutcome GetTokenBalance(const Model::GetTokenBalanceRequest& request) const;
 
  template <typename GetTokenBalanceRequestT = Model::GetTokenBalanceRequest>
  Model::GetTokenBalanceOutcomeCallable GetTokenBalanceCallable(const GetTokenBalanceRequestT& request) const {
    return SubmitCallable(&ManagedBlockchainQueryClient::GetTokenBalance, request);
  }
 
  template <typename GetTokenBalanceRequestT = Model::GetTokenBalanceRequest>
  void GetTokenBalanceAsync(const GetTokenBalanceRequestT& request, const GetTokenBalanceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedBlockchainQueryClient::GetTokenBalance, request, handler, context);
  }
 
  virtual Model::GetTransactionOutcome GetTransaction(const Model::GetTransactionRequest& request) const;
 
  template <typename GetTransactionRequestT = Model::GetTransactionRequest>
  Model::GetTransactionOutcomeCallable GetTransactionCallable(const GetTransactionRequestT& request) const {
    return SubmitCallable(&ManagedBlockchainQueryClient::GetTransaction, request);
  }
 
  template <typename GetTransactionRequestT = Model::GetTransactionRequest>
  void GetTransactionAsync(const GetTransactionRequestT& request, const GetTransactionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedBlockchainQueryClient::GetTransaction, request, handler, context);
  }
 
  virtual Model::ListAssetContractsOutcome ListAssetContracts(const Model::ListAssetContractsRequest& request) const;
 
  template <typename ListAssetContractsRequestT = Model::ListAssetContractsRequest>
  Model::ListAssetContractsOutcomeCallable ListAssetContractsCallable(const ListAssetContractsRequestT& request) const {
    return SubmitCallable(&ManagedBlockchainQueryClient::ListAssetContracts, request);
  }
 
  template <typename ListAssetContractsRequestT = Model::ListAssetContractsRequest>
  void ListAssetContractsAsync(const ListAssetContractsRequestT& request, const ListAssetContractsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedBlockchainQueryClient::ListAssetContracts, request, handler, context);
  }
 
  virtual Model::ListFilteredTransactionEventsOutcome ListFilteredTransactionEvents(
      const Model::ListFilteredTransactionEventsRequest& request) const;
 
  template <typename ListFilteredTransactionEventsRequestT = Model::ListFilteredTransactionEventsRequest>
  Model::ListFilteredTransactionEventsOutcomeCallable ListFilteredTransactionEventsCallable(
      const ListFilteredTransactionEventsRequestT& request) const {
    return SubmitCallable(&ManagedBlockchainQueryClient::ListFilteredTransactionEvents, request);
  }
 
  template <typename ListFilteredTransactionEventsRequestT = Model::ListFilteredTransactionEventsRequest>
  void ListFilteredTransactionEventsAsync(const ListFilteredTransactionEventsRequestT& request,
                                          const ListFilteredTransactionEventsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedBlockchainQueryClient::ListFilteredTransactionEvents, request, handler, context);
  }
 
  virtual Model::ListTokenBalancesOutcome ListTokenBalances(const Model::ListTokenBalancesRequest& request) const;
 
  template <typename ListTokenBalancesRequestT = Model::ListTokenBalancesRequest>
  Model::ListTokenBalancesOutcomeCallable ListTokenBalancesCallable(const ListTokenBalancesRequestT& request) const {
    return SubmitCallable(&ManagedBlockchainQueryClient::ListTokenBalances, request);
  }
 
  template <typename ListTokenBalancesRequestT = Model::ListTokenBalancesRequest>
  void ListTokenBalancesAsync(const ListTokenBalancesRequestT& request, const ListTokenBalancesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedBlockchainQueryClient::ListTokenBalances, request, handler, context);
  }
 
  virtual Model::ListTransactionEventsOutcome ListTransactionEvents(const Model::ListTransactionEventsRequest& request) const;
 
  template <typename ListTransactionEventsRequestT = Model::ListTransactionEventsRequest>
  Model::ListTransactionEventsOutcomeCallable ListTransactionEventsCallable(const ListTransactionEventsRequestT& request) const {
    return SubmitCallable(&ManagedBlockchainQueryClient::ListTransactionEvents, request);
  }
 
  template <typename ListTransactionEventsRequestT = Model::ListTransactionEventsRequest>
  void ListTransactionEventsAsync(const ListTransactionEventsRequestT& request, const ListTransactionEventsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedBlockchainQueryClient::ListTransactionEvents, request, handler, context);
  }
 
  virtual Model::ListTransactionsOutcome ListTransactions(const Model::ListTransactionsRequest& request) const;
 
  template <typename ListTransactionsRequestT = Model::ListTransactionsRequest>
  Model::ListTransactionsOutcomeCallable ListTransactionsCallable(const ListTransactionsRequestT& request) const {
    return SubmitCallable(&ManagedBlockchainQueryClient::ListTransactions, request);
  }
 
  template <typename ListTransactionsRequestT = Model::ListTransactionsRequest>
  void ListTransactionsAsync(const ListTransactionsRequestT& request, const ListTransactionsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ManagedBlockchainQueryClient::ListTransactions, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ManagedBlockchainQueryEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ManagedBlockchainQueryClient>;
  void init(const ManagedBlockchainQueryClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ManagedBlockchainQueryError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ManagedBlockchainQueryClientConfiguration m_clientConfiguration;
  std::shared_ptr<ManagedBlockchainQueryEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ManagedBlockchainQuery
}  // namespace Aws