S3FilesClient.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/s3files/S3FilesPaginationBase.h>
#include <aws/s3files/S3FilesServiceClientModel.h>
#include <aws/s3files/S3FilesWaiter.h>
#include <aws/s3files/S3Files_EXPORTS.h>
 
namespace Aws {
namespace S3Files {
class AWS_S3FILES_API S3FilesClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<S3FilesClient>,
                                      public S3FilesPaginationBase<S3FilesClient>,
                                      public S3FilesWaiter<S3FilesClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef S3FilesClientConfiguration ClientConfigurationType;
  typedef S3FilesEndpointProvider EndpointProviderType;
 
  S3FilesClient(const Aws::S3Files::S3FilesClientConfiguration& clientConfiguration = Aws::S3Files::S3FilesClientConfiguration(),
                std::shared_ptr<S3FilesEndpointProviderBase> endpointProvider = nullptr);
 
  S3FilesClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<S3FilesEndpointProviderBase> endpointProvider = nullptr,
                const Aws::S3Files::S3FilesClientConfiguration& clientConfiguration = Aws::S3Files::S3FilesClientConfiguration());
 
  S3FilesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<S3FilesEndpointProviderBase> endpointProvider = nullptr,
                const Aws::S3Files::S3FilesClientConfiguration& clientConfiguration = Aws::S3Files::S3FilesClientConfiguration());
 
  /* Legacy constructors due deprecation */
  S3FilesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  S3FilesClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  S3FilesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~S3FilesClient();
 
  virtual Model::CreateAccessPointOutcome CreateAccessPoint(const Model::CreateAccessPointRequest& request) const;
 
  template <typename CreateAccessPointRequestT = Model::CreateAccessPointRequest>
  Model::CreateAccessPointOutcomeCallable CreateAccessPointCallable(const CreateAccessPointRequestT& request) const {
    return SubmitCallable(&S3FilesClient::CreateAccessPoint, request);
  }
 
  template <typename CreateAccessPointRequestT = Model::CreateAccessPointRequest>
  void CreateAccessPointAsync(const CreateAccessPointRequestT& request, const CreateAccessPointResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::CreateAccessPoint, request, handler, context);
  }
 
  virtual Model::CreateFileSystemOutcome CreateFileSystem(const Model::CreateFileSystemRequest& request) const;
 
  template <typename CreateFileSystemRequestT = Model::CreateFileSystemRequest>
  Model::CreateFileSystemOutcomeCallable CreateFileSystemCallable(const CreateFileSystemRequestT& request) const {
    return SubmitCallable(&S3FilesClient::CreateFileSystem, request);
  }
 
  template <typename CreateFileSystemRequestT = Model::CreateFileSystemRequest>
  void CreateFileSystemAsync(const CreateFileSystemRequestT& request, const CreateFileSystemResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::CreateFileSystem, request, handler, context);
  }
 
  virtual Model::CreateMountTargetOutcome CreateMountTarget(const Model::CreateMountTargetRequest& request) const;
 
  template <typename CreateMountTargetRequestT = Model::CreateMountTargetRequest>
  Model::CreateMountTargetOutcomeCallable CreateMountTargetCallable(const CreateMountTargetRequestT& request) const {
    return SubmitCallable(&S3FilesClient::CreateMountTarget, request);
  }
 
  template <typename CreateMountTargetRequestT = Model::CreateMountTargetRequest>
  void CreateMountTargetAsync(const CreateMountTargetRequestT& request, const CreateMountTargetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::CreateMountTarget, request, handler, context);
  }
 
  virtual Model::DeleteAccessPointOutcome DeleteAccessPoint(const Model::DeleteAccessPointRequest& request) const;
 
  template <typename DeleteAccessPointRequestT = Model::DeleteAccessPointRequest>
  Model::DeleteAccessPointOutcomeCallable DeleteAccessPointCallable(const DeleteAccessPointRequestT& request) const {
    return SubmitCallable(&S3FilesClient::DeleteAccessPoint, request);
  }
 
  template <typename DeleteAccessPointRequestT = Model::DeleteAccessPointRequest>
  void DeleteAccessPointAsync(const DeleteAccessPointRequestT& request, const DeleteAccessPointResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::DeleteAccessPoint, request, handler, context);
  }
 
  virtual Model::DeleteFileSystemOutcome DeleteFileSystem(const Model::DeleteFileSystemRequest& request) const;
 
  template <typename DeleteFileSystemRequestT = Model::DeleteFileSystemRequest>
  Model::DeleteFileSystemOutcomeCallable DeleteFileSystemCallable(const DeleteFileSystemRequestT& request) const {
    return SubmitCallable(&S3FilesClient::DeleteFileSystem, request);
  }
 
  template <typename DeleteFileSystemRequestT = Model::DeleteFileSystemRequest>
  void DeleteFileSystemAsync(const DeleteFileSystemRequestT& request, const DeleteFileSystemResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::DeleteFileSystem, request, handler, context);
  }
 
  virtual Model::DeleteFileSystemPolicyOutcome DeleteFileSystemPolicy(const Model::DeleteFileSystemPolicyRequest& request) const;
 
  template <typename DeleteFileSystemPolicyRequestT = Model::DeleteFileSystemPolicyRequest>
  Model::DeleteFileSystemPolicyOutcomeCallable DeleteFileSystemPolicyCallable(const DeleteFileSystemPolicyRequestT& request) const {
    return SubmitCallable(&S3FilesClient::DeleteFileSystemPolicy, request);
  }
 
  template <typename DeleteFileSystemPolicyRequestT = Model::DeleteFileSystemPolicyRequest>
  void DeleteFileSystemPolicyAsync(const DeleteFileSystemPolicyRequestT& request,
                                   const DeleteFileSystemPolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::DeleteFileSystemPolicy, request, handler, context);
  }
 
  virtual Model::DeleteMountTargetOutcome DeleteMountTarget(const Model::DeleteMountTargetRequest& request) const;
 
  template <typename DeleteMountTargetRequestT = Model::DeleteMountTargetRequest>
  Model::DeleteMountTargetOutcomeCallable DeleteMountTargetCallable(const DeleteMountTargetRequestT& request) const {
    return SubmitCallable(&S3FilesClient::DeleteMountTarget, request);
  }
 
  template <typename DeleteMountTargetRequestT = Model::DeleteMountTargetRequest>
  void DeleteMountTargetAsync(const DeleteMountTargetRequestT& request, const DeleteMountTargetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::DeleteMountTarget, request, handler, context);
  }
 
  virtual Model::GetAccessPointOutcome GetAccessPoint(const Model::GetAccessPointRequest& request) const;
 
  template <typename GetAccessPointRequestT = Model::GetAccessPointRequest>
  Model::GetAccessPointOutcomeCallable GetAccessPointCallable(const GetAccessPointRequestT& request) const {
    return SubmitCallable(&S3FilesClient::GetAccessPoint, request);
  }
 
  template <typename GetAccessPointRequestT = Model::GetAccessPointRequest>
  void GetAccessPointAsync(const GetAccessPointRequestT& request, const GetAccessPointResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::GetAccessPoint, request, handler, context);
  }
 
  virtual Model::GetFileSystemOutcome GetFileSystem(const Model::GetFileSystemRequest& request) const;
 
  template <typename GetFileSystemRequestT = Model::GetFileSystemRequest>
  Model::GetFileSystemOutcomeCallable GetFileSystemCallable(const GetFileSystemRequestT& request) const {
    return SubmitCallable(&S3FilesClient::GetFileSystem, request);
  }
 
  template <typename GetFileSystemRequestT = Model::GetFileSystemRequest>
  void GetFileSystemAsync(const GetFileSystemRequestT& request, const GetFileSystemResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::GetFileSystem, request, handler, context);
  }
 
  virtual Model::GetFileSystemPolicyOutcome GetFileSystemPolicy(const Model::GetFileSystemPolicyRequest& request) const;
 
  template <typename GetFileSystemPolicyRequestT = Model::GetFileSystemPolicyRequest>
  Model::GetFileSystemPolicyOutcomeCallable GetFileSystemPolicyCallable(const GetFileSystemPolicyRequestT& request) const {
    return SubmitCallable(&S3FilesClient::GetFileSystemPolicy, request);
  }
 
  template <typename GetFileSystemPolicyRequestT = Model::GetFileSystemPolicyRequest>
  void GetFileSystemPolicyAsync(const GetFileSystemPolicyRequestT& request, const GetFileSystemPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::GetFileSystemPolicy, request, handler, context);
  }
 
  virtual Model::GetMountTargetOutcome GetMountTarget(const Model::GetMountTargetRequest& request) const;
 
  template <typename GetMountTargetRequestT = Model::GetMountTargetRequest>
  Model::GetMountTargetOutcomeCallable GetMountTargetCallable(const GetMountTargetRequestT& request) const {
    return SubmitCallable(&S3FilesClient::GetMountTarget, request);
  }
 
  template <typename GetMountTargetRequestT = Model::GetMountTargetRequest>
  void GetMountTargetAsync(const GetMountTargetRequestT& request, const GetMountTargetResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::GetMountTarget, request, handler, context);
  }
 
  virtual Model::GetSynchronizationConfigurationOutcome GetSynchronizationConfiguration(
      const Model::GetSynchronizationConfigurationRequest& request) const;
 
  template <typename GetSynchronizationConfigurationRequestT = Model::GetSynchronizationConfigurationRequest>
  Model::GetSynchronizationConfigurationOutcomeCallable GetSynchronizationConfigurationCallable(
      const GetSynchronizationConfigurationRequestT& request) const {
    return SubmitCallable(&S3FilesClient::GetSynchronizationConfiguration, request);
  }
 
  template <typename GetSynchronizationConfigurationRequestT = Model::GetSynchronizationConfigurationRequest>
  void GetSynchronizationConfigurationAsync(const GetSynchronizationConfigurationRequestT& request,
                                            const GetSynchronizationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::GetSynchronizationConfiguration, request, handler, context);
  }
 
  virtual Model::ListAccessPointsOutcome ListAccessPoints(const Model::ListAccessPointsRequest& request) const;
 
  template <typename ListAccessPointsRequestT = Model::ListAccessPointsRequest>
  Model::ListAccessPointsOutcomeCallable ListAccessPointsCallable(const ListAccessPointsRequestT& request) const {
    return SubmitCallable(&S3FilesClient::ListAccessPoints, request);
  }
 
  template <typename ListAccessPointsRequestT = Model::ListAccessPointsRequest>
  void ListAccessPointsAsync(const ListAccessPointsRequestT& request, const ListAccessPointsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::ListAccessPoints, request, handler, context);
  }
 
  virtual Model::ListFileSystemsOutcome ListFileSystems(const Model::ListFileSystemsRequest& request = {}) const;
 
  template <typename ListFileSystemsRequestT = Model::ListFileSystemsRequest>
  Model::ListFileSystemsOutcomeCallable ListFileSystemsCallable(const ListFileSystemsRequestT& request = {}) const {
    return SubmitCallable(&S3FilesClient::ListFileSystems, request);
  }
 
  template <typename ListFileSystemsRequestT = Model::ListFileSystemsRequest>
  void ListFileSystemsAsync(const ListFileSystemsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListFileSystemsRequestT& request = {}) const {
    return SubmitAsync(&S3FilesClient::ListFileSystems, request, handler, context);
  }
 
  virtual Model::ListMountTargetsOutcome ListMountTargets(const Model::ListMountTargetsRequest& request = {}) const;
 
  template <typename ListMountTargetsRequestT = Model::ListMountTargetsRequest>
  Model::ListMountTargetsOutcomeCallable ListMountTargetsCallable(const ListMountTargetsRequestT& request = {}) const {
    return SubmitCallable(&S3FilesClient::ListMountTargets, request);
  }
 
  template <typename ListMountTargetsRequestT = Model::ListMountTargetsRequest>
  void ListMountTargetsAsync(const ListMountTargetsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListMountTargetsRequestT& request = {}) const {
    return SubmitAsync(&S3FilesClient::ListMountTargets, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&S3FilesClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutFileSystemPolicyOutcome PutFileSystemPolicy(const Model::PutFileSystemPolicyRequest& request) const;
 
  template <typename PutFileSystemPolicyRequestT = Model::PutFileSystemPolicyRequest>
  Model::PutFileSystemPolicyOutcomeCallable PutFileSystemPolicyCallable(const PutFileSystemPolicyRequestT& request) const {
    return SubmitCallable(&S3FilesClient::PutFileSystemPolicy, request);
  }
 
  template <typename PutFileSystemPolicyRequestT = Model::PutFileSystemPolicyRequest>
  void PutFileSystemPolicyAsync(const PutFileSystemPolicyRequestT& request, const PutFileSystemPolicyResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::PutFileSystemPolicy, request, handler, context);
  }
 
  virtual Model::PutSynchronizationConfigurationOutcome PutSynchronizationConfiguration(
      const Model::PutSynchronizationConfigurationRequest& request) const;
 
  template <typename PutSynchronizationConfigurationRequestT = Model::PutSynchronizationConfigurationRequest>
  Model::PutSynchronizationConfigurationOutcomeCallable PutSynchronizationConfigurationCallable(
      const PutSynchronizationConfigurationRequestT& request) const {
    return SubmitCallable(&S3FilesClient::PutSynchronizationConfiguration, request);
  }
 
  template <typename PutSynchronizationConfigurationRequestT = Model::PutSynchronizationConfigurationRequest>
  void PutSynchronizationConfigurationAsync(const PutSynchronizationConfigurationRequestT& request,
                                            const PutSynchronizationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::PutSynchronizationConfiguration, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&S3FilesClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&S3FilesClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateMountTargetOutcome UpdateMountTarget(const Model::UpdateMountTargetRequest& request) const;
 
  template <typename UpdateMountTargetRequestT = Model::UpdateMountTargetRequest>
  Model::UpdateMountTargetOutcomeCallable UpdateMountTargetCallable(const UpdateMountTargetRequestT& request) const {
    return SubmitCallable(&S3FilesClient::UpdateMountTarget, request);
  }
 
  template <typename UpdateMountTargetRequestT = Model::UpdateMountTargetRequest>
  void UpdateMountTargetAsync(const UpdateMountTargetRequestT& request, const UpdateMountTargetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&S3FilesClient::UpdateMountTarget, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<S3FilesEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<S3FilesClient>;
  void init(const S3FilesClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, S3FilesError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  S3FilesClientConfiguration m_clientConfiguration;
  std::shared_ptr<S3FilesEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace S3Files
}  // namespace Aws