datalake_directory_client.hpp

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
 
#pragma once
 
#include "azure/storage/files/datalake/datalake_options.hpp"
#include "azure/storage/files/datalake/datalake_path_client.hpp"
#include "azure/storage/files/datalake/datalake_responses.hpp"
 
#include <azure/core/credentials/credentials.hpp>
#include <azure/core/internal/http/pipeline.hpp>
#include <azure/core/response.hpp>
#include <azure/storage/common/storage_credential.hpp>
 
#include <memory>
#include <string>
#include <vector>
 
namespace Azure { namespace Storage { namespace Files { namespace DataLake {
 
  class DataLakeDirectoryClient final : public DataLakePathClient {
  public:
    static DataLakeDirectoryClient CreateFromConnectionString(
        const std::string& connectionString,
        const std::string& fileSystemName,
        const std::string& directoryName,
        const DataLakeClientOptions& options = DataLakeClientOptions());
 
    explicit DataLakeDirectoryClient(
        const std::string& directoryUrl,
        std::shared_ptr<StorageSharedKeyCredential> credential,
        const DataLakeClientOptions& options = DataLakeClientOptions());
 
    explicit DataLakeDirectoryClient(
        const std::string& directoryUrl,
        std::shared_ptr<const Core::Credentials::TokenCredential> credential,
        const DataLakeClientOptions& options = DataLakeClientOptions());
 
    explicit DataLakeDirectoryClient(
        const std::string& directoryUrl,
        const DataLakeClientOptions& options = DataLakeClientOptions());
 
    DataLakeFileClient GetFileClient(const std::string& fileName) const;
 
    DataLakeDirectoryClient GetSubdirectoryClient(const std::string& subdirectoryName) const;
 
    std::string GetUrl() const { return m_blobClient.GetUrl(); }
 
    Azure::Response<Models::CreateDirectoryResult> Create(
        const CreateDirectoryOptions& options = CreateDirectoryOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const
    {
      return DataLakePathClient::Create(Models::PathResourceType::Directory, options, context);
    }
 
    Azure::Response<Models::CreateDirectoryResult> CreateIfNotExists(
        const CreateDirectoryOptions& options = CreateDirectoryOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const
    {
      return DataLakePathClient::CreateIfNotExists(
          Models::PathResourceType::Directory, options, context);
    }
 
    Azure::Response<DataLakeFileClient> RenameFile(
        const std::string& fileName,
        const std::string& destinationFilePath,
        const RenameFileOptions& options = RenameFileOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const;
 
    Azure::Response<DataLakeDirectoryClient> RenameSubdirectory(
        const std::string& subdirectoryName,
        const std::string& destinationDirectoryPath,
        const RenameSubdirectoryOptions& options = RenameSubdirectoryOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const;
 
    Azure::Response<Models::DeleteDirectoryResult> DeleteEmpty(
        const DeleteDirectoryOptions& options = DeleteDirectoryOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const
    {
      return this->Delete(false, options, context);
    }
 
    Azure::Response<Models::DeleteDirectoryResult> DeleteEmptyIfExists(
        const DeleteDirectoryOptions& options = DeleteDirectoryOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const
    {
      return this->DeleteIfExists(false, options, context);
    }
 
    Azure::Response<Models::DeleteDirectoryResult> DeleteRecursive(
        const DeleteDirectoryOptions& options = DeleteDirectoryOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const
    {
      return this->Delete(true, options, context);
    }
 
    Azure::Response<Models::DeleteDirectoryResult> DeleteRecursiveIfExists(
        const DeleteDirectoryOptions& options = DeleteDirectoryOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const
    {
      return this->DeleteIfExists(true, options, context);
    }
 
    ListPathsPagedResponse ListPaths(
        bool recursive,
        const ListPathsOptions& options = ListPathsOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const;
 
  private:
    explicit DataLakeDirectoryClient(
        Azure::Core::Url directoryUrl,
        Blobs::BlobClient blobClient,
        std::shared_ptr<Azure::Core::Http::_internal::HttpPipeline> pipeline,
        _detail::DatalakeClientConfiguration clientConfiguration)
        : DataLakePathClient(
            std::move(directoryUrl),
            std::move(blobClient),
            pipeline,
            std::move(clientConfiguration))
    {
    }
 
    Azure::Response<Models::DeleteDirectoryResult> Delete(
        bool recursive,
        const DeleteDirectoryOptions& options = DeleteDirectoryOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const;
 
    Azure::Response<Models::DeleteDirectoryResult> DeleteIfExists(
        bool recursive,
        const DeleteDirectoryOptions& options = DeleteDirectoryOptions(),
        const Azure::Core::Context& context = Azure::Core::Context()) const;
 
    friend class DataLakeFileSystemClient;
  };
}}}} // namespace Azure::Storage::Files::DataLake