From 535c77c9eca574539f1609d37e4b9c8839f61d16 Mon Sep 17 00:00:00 2001 From: Kan Tang Date: Wed, 6 Jan 2021 21:46:44 +0800 Subject: [PATCH] Integrate extensible enum (#1275) * Integrate extensible enum * Resolve review comments --- .../azure-storage-files-datalake/CHANGELOG.md | 1 + .../CMakeLists.txt | 1 + .../files/datalake/datalake_responses.hpp | 4 +- .../protocol/datalake_rest_client.hpp | 595 ++++++------------ .../src/datalake_file_client.cpp | 4 +- .../src/datalake_path_client.cpp | 4 +- .../src/datalake_rest_client.cpp | 45 ++ .../azure-storage-files-shares/CHANGELOG.md | 1 + .../azure-storage-files-shares/CMakeLists.txt | 1 + .../shares/protocol/share_rest_client.hpp | 551 +++++----------- .../src/share_rest_client.cpp | 41 ++ 11 files changed, 452 insertions(+), 796 deletions(-) create mode 100644 sdk/storage/azure-storage-files-datalake/src/datalake_rest_client.cpp create mode 100644 sdk/storage/azure-storage-files-shares/src/share_rest_client.cpp diff --git a/sdk/storage/azure-storage-files-datalake/CHANGELOG.md b/sdk/storage/azure-storage-files-datalake/CHANGELOG.md index 17516601a..20fa24d1c 100644 --- a/sdk/storage/azure-storage-files-datalake/CHANGELOG.md +++ b/sdk/storage/azure-storage-files-datalake/CHANGELOG.md @@ -18,6 +18,7 @@ - Renamed all functions and structures that could retrieve partial query results from the server to have `SinglePage` suffix instead of `Segment` suffix. - `ReadFileResult` now have `ContentRange` as string. - `ReadFileOptions` now have `Azure::Core::Http::Range Range` instead of `Content-Length` and `Offset`. +- Replace scoped enums that don't support bitwise operations with extensible enum. ## 12.0.0-beta.5 (2020-11-13) diff --git a/sdk/storage/azure-storage-files-datalake/CMakeLists.txt b/sdk/storage/azure-storage-files-datalake/CMakeLists.txt index b3d69f799..0a8530629 100644 --- a/sdk/storage/azure-storage-files-datalake/CMakeLists.txt +++ b/sdk/storage/azure-storage-files-datalake/CMakeLists.txt @@ -49,6 +49,7 @@ set( src/datalake_file_system_client.cpp src/datalake_path_client.cpp src/datalake_responses.cpp + src/datalake_rest_client.cpp src/datalake_sas_builder.cpp src/datalake_service_client.cpp src/datalake_utilities.cpp diff --git a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp index 359528e65..cdb4f6b00 100644 --- a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp +++ b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp @@ -147,8 +147,8 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { nam std::string ETag; Core::DateTime LastModified; Azure::Core::Nullable LeaseDuration; - LeaseStateType LeaseState = LeaseStateType::Unknown; - LeaseStatusType LeaseStatus = LeaseStatusType::Unknown; + LeaseStateType LeaseState; + LeaseStatusType LeaseStatus; Storage::Metadata Metadata; Core::DateTime CreatedOn; Azure::Core::Nullable ExpiresOn; diff --git a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp index 85f1ea063..c595ab4ea 100644 --- a/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp +++ b/sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp @@ -107,34 +107,68 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { std::string ContentType; Storage::ContentHash ContentHash; }; + // The value must be "filesystem" for all filesystem operations. - enum class FileSystemResourceType - { - Filesystem, - Unknown - }; + class FileSystemResourceType { + public: + FileSystemResourceType() = default; + explicit FileSystemResourceType(std::string value) : m_value(std::move(value)) {} + bool operator==(const FileSystemResourceType& other) const + { + return m_value == other.m_value; + } + bool operator!=(const FileSystemResourceType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static FileSystemResourceType Filesystem; + + private: + std::string m_value; + }; // extensible enum FileSystemResourceType // Mode "set" sets POSIX access control rights on files and directories, "modify" modifies one // or more POSIX access control rights that pre-exist on files and directories, "remove" // removes one or more POSIX access control rights that were present earlier on files and // directories - enum class PathSetAccessControlRecursiveMode - { - Set, - Modify, - Remove, - Unknown - }; + class PathSetAccessControlRecursiveMode { + public: + PathSetAccessControlRecursiveMode() = default; + explicit PathSetAccessControlRecursiveMode(std::string value) : m_value(std::move(value)) {} + bool operator==(const PathSetAccessControlRecursiveMode& other) const + { + return m_value == other.m_value; + } + bool operator!=(const PathSetAccessControlRecursiveMode& other) const + { + return !(*this == other); + } + const std::string& Get() const { return m_value; } + + const static PathSetAccessControlRecursiveMode Set; + const static PathSetAccessControlRecursiveMode Modify; + const static PathSetAccessControlRecursiveMode Remove; + + private: + std::string m_value; + }; // extensible enum PathSetAccessControlRecursiveMode // Required. Indicates mode of the expiry time - enum class PathExpiryOptions - { - NeverExpire, - RelativeToCreation, - RelativeToNow, - Absolute, - Unknown - }; + class PathExpiryOptions { + public: + PathExpiryOptions() = default; + explicit PathExpiryOptions(std::string value) : m_value(std::move(value)) {} + bool operator==(const PathExpiryOptions& other) const { return m_value == other.m_value; } + bool operator!=(const PathExpiryOptions& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static PathExpiryOptions NeverExpire; + const static PathExpiryOptions RelativeToCreation; + const static PathExpiryOptions RelativeToNow; + const static PathExpiryOptions Absolute; + + private: + std::string m_value; + }; // extensible enum PathExpiryOptions struct AclFailedEntry { @@ -181,29 +215,53 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { }; // The value must be "account" for all account operations. - enum class AccountResourceType - { - Account, - Unknown - }; + class AccountResourceType { + public: + AccountResourceType() = default; + explicit AccountResourceType(std::string value) : m_value(std::move(value)) {} + bool operator==(const AccountResourceType& other) const { return m_value == other.m_value; } + bool operator!=(const AccountResourceType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static AccountResourceType Account; + + private: + std::string m_value; + }; // extensible enum AccountResourceType // Required only for Create File and Create Directory. The value must be "file" or "directory". - enum class PathResourceType - { - Directory, - File, - Unknown - }; + class PathResourceType { + public: + PathResourceType() = default; + explicit PathResourceType(std::string value) : m_value(std::move(value)) {} + bool operator==(const PathResourceType& other) const { return m_value == other.m_value; } + bool operator!=(const PathResourceType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static PathResourceType Directory; + const static PathResourceType File; + + private: + std::string m_value; + }; // extensible enum PathResourceType // Optional. Valid only when namespace is enabled. This parameter determines the behavior of the // rename operation. The value must be "legacy" or "posix", and the default value will be // "posix". - enum class PathRenameMode - { - Legacy, - Posix, - Unknown - }; + class PathRenameMode { + public: + PathRenameMode() = default; + explicit PathRenameMode(std::string value) : m_value(std::move(value)) {} + bool operator==(const PathRenameMode& other) const { return m_value == other.m_value; } + bool operator!=(const PathRenameMode& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static PathRenameMode Legacy; + const static PathRenameMode Posix; + + private: + std::string m_value; + }; // extensible enum PathRenameMode // There are five lease actions: "acquire", "break", "change", "renew", and "release". Use // "acquire" and specify the "x-ms-proposed-lease-id" and "x-ms-lease-duration" to acquire a new @@ -214,45 +272,80 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { // lease ID in "x-ms-lease-id" and the new lease ID in "x-ms-proposed-lease-id" to change the // lease ID of an active lease. Use "renew" and specify the "x-ms-lease-id" to renew an existing // lease. Use "release" and specify the "x-ms-lease-id" to release a lease. - enum class PathLeaseAction - { - Acquire, - Break, - Change, - Renew, - Release, - Unknown - }; + class PathLeaseAction { + public: + PathLeaseAction() = default; + explicit PathLeaseAction(std::string value) : m_value(std::move(value)) {} + bool operator==(const PathLeaseAction& other) const { return m_value == other.m_value; } + bool operator!=(const PathLeaseAction& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static PathLeaseAction Acquire; + const static PathLeaseAction Break; + const static PathLeaseAction Change; + const static PathLeaseAction Renew; + const static PathLeaseAction Release; + + private: + std::string m_value; + }; // extensible enum PathLeaseAction // Optional. If the value is "getStatus" only the system defined properties for the path are // returned. If the value is "getAccessControl" the access control list is returned in the // response headers (Hierarchical Namespace must be enabled for the account), otherwise the // properties are returned. - enum class PathGetPropertiesAction - { - GetAccessControl, - GetStatus, - Unknown - }; + class PathGetPropertiesAction { + public: + PathGetPropertiesAction() = default; + explicit PathGetPropertiesAction(std::string value) : m_value(std::move(value)) {} + bool operator==(const PathGetPropertiesAction& other) const + { + return m_value == other.m_value; + } + bool operator!=(const PathGetPropertiesAction& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static PathGetPropertiesAction GetAccessControl; + const static PathGetPropertiesAction GetStatus; + + private: + std::string m_value; + }; // extensible enum PathGetPropertiesAction // Lease state of the resource. - enum class LeaseStateType - { - Available, - Leased, - Expired, - Breaking, - Broken, - Unknown - }; + class LeaseStateType { + public: + LeaseStateType() = default; + explicit LeaseStateType(std::string value) : m_value(std::move(value)) {} + bool operator==(const LeaseStateType& other) const { return m_value == other.m_value; } + bool operator!=(const LeaseStateType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static LeaseStateType Available; + const static LeaseStateType Leased; + const static LeaseStateType Expired; + const static LeaseStateType Breaking; + const static LeaseStateType Broken; + + private: + std::string m_value; + }; // extensible enum LeaseStateType // The lease status of the resource. - enum class LeaseStatusType - { - Locked, - Unlocked, - Unknown - }; + class LeaseStatusType { + public: + LeaseStatusType() = default; + explicit LeaseStatusType(std::string value) : m_value(std::move(value)) {} + bool operator==(const LeaseStatusType& other) const { return m_value == other.m_value; } + bool operator!=(const LeaseStatusType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static LeaseStatusType Locked; + const static LeaseStatusType Unlocked; + + private: + std::string m_value; + }; // extensible enum LeaseStatusType struct ServiceListFileSystemsResult { @@ -367,320 +460,6 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { } // namespace Models namespace Details { - inline std::string FileSystemResourceTypeToString( - const Models::FileSystemResourceType& fileSystemResourceType) - { - switch (fileSystemResourceType) - { - case Models::FileSystemResourceType::Filesystem: - return "filesystem"; - default: - return std::string(); - } - } - - inline Models::FileSystemResourceType FileSystemResourceTypeFromString( - const std::string& fileSystemResourceType) - { - if (fileSystemResourceType == "filesystem") - { - return Models::FileSystemResourceType::Filesystem; - } - throw std::runtime_error( - "Cannot convert " + fileSystemResourceType + " to FileSystemResourceType"); - } - - inline std::string PathSetAccessControlRecursiveModeToString( - const Models::PathSetAccessControlRecursiveMode& pathSetAccessControlRecursiveMode) - { - switch (pathSetAccessControlRecursiveMode) - { - case Models::PathSetAccessControlRecursiveMode::Set: - return "set"; - case Models::PathSetAccessControlRecursiveMode::Modify: - return "modify"; - case Models::PathSetAccessControlRecursiveMode::Remove: - return "remove"; - default: - return std::string(); - } - } - - inline Models::PathSetAccessControlRecursiveMode PathSetAccessControlRecursiveModeFromString( - const std::string& pathSetAccessControlRecursiveMode) - { - if (pathSetAccessControlRecursiveMode == "set") - { - return Models::PathSetAccessControlRecursiveMode::Set; - } - if (pathSetAccessControlRecursiveMode == "modify") - { - return Models::PathSetAccessControlRecursiveMode::Modify; - } - if (pathSetAccessControlRecursiveMode == "remove") - { - return Models::PathSetAccessControlRecursiveMode::Remove; - } - throw std::runtime_error( - "Cannot convert " + pathSetAccessControlRecursiveMode - + " to PathSetAccessControlRecursiveMode"); - } - - inline std::string PathExpiryOptionsToString(const Models::PathExpiryOptions& pathExpiryOptions) - { - switch (pathExpiryOptions) - { - case Models::PathExpiryOptions::NeverExpire: - return "NeverExpire"; - case Models::PathExpiryOptions::RelativeToCreation: - return "RelativeToCreation"; - case Models::PathExpiryOptions::RelativeToNow: - return "RelativeToNow"; - case Models::PathExpiryOptions::Absolute: - return "Absolute"; - default: - return std::string(); - } - } - - inline Models::PathExpiryOptions PathExpiryOptionsFromString( - const std::string& pathExpiryOptions) - { - if (pathExpiryOptions == "NeverExpire") - { - return Models::PathExpiryOptions::NeverExpire; - } - if (pathExpiryOptions == "RelativeToCreation") - { - return Models::PathExpiryOptions::RelativeToCreation; - } - if (pathExpiryOptions == "RelativeToNow") - { - return Models::PathExpiryOptions::RelativeToNow; - } - if (pathExpiryOptions == "Absolute") - { - return Models::PathExpiryOptions::Absolute; - } - throw std::runtime_error("Cannot convert " + pathExpiryOptions + " to PathExpiryOptions"); - } - - inline std::string AccountResourceTypeToString( - const Models::AccountResourceType& accountResourceType) - { - switch (accountResourceType) - { - case Models::AccountResourceType::Account: - return "account"; - default: - return std::string(); - } - } - - inline Models::AccountResourceType AccountResourceTypeFromString( - const std::string& accountResourceType) - { - if (accountResourceType == "account") - { - return Models::AccountResourceType::Account; - } - throw std::runtime_error("Cannot convert " + accountResourceType + " to AccountResourceType"); - } - - inline std::string PathResourceTypeToString(const Models::PathResourceType& pathResourceType) - { - switch (pathResourceType) - { - case Models::PathResourceType::Directory: - return "directory"; - case Models::PathResourceType::File: - return "file"; - default: - return std::string(); - } - } - - inline Models::PathResourceType PathResourceTypeFromString(const std::string& pathResourceType) - { - if (pathResourceType == "directory") - { - return Models::PathResourceType::Directory; - } - if (pathResourceType == "file") - { - return Models::PathResourceType::File; - } - throw std::runtime_error("Cannot convert " + pathResourceType + " to PathResourceType"); - } - - inline std::string PathRenameModeToString(const Models::PathRenameMode& pathRenameMode) - { - switch (pathRenameMode) - { - case Models::PathRenameMode::Legacy: - return "legacy"; - case Models::PathRenameMode::Posix: - return "posix"; - default: - return std::string(); - } - } - - inline Models::PathRenameMode PathRenameModeFromString(const std::string& pathRenameMode) - { - if (pathRenameMode == "legacy") - { - return Models::PathRenameMode::Legacy; - } - if (pathRenameMode == "posix") - { - return Models::PathRenameMode::Posix; - } - throw std::runtime_error("Cannot convert " + pathRenameMode + " to PathRenameMode"); - } - - inline std::string PathLeaseActionToString(const Models::PathLeaseAction& pathLeaseAction) - { - switch (pathLeaseAction) - { - case Models::PathLeaseAction::Acquire: - return "acquire"; - case Models::PathLeaseAction::Break: - return "break"; - case Models::PathLeaseAction::Change: - return "change"; - case Models::PathLeaseAction::Renew: - return "renew"; - case Models::PathLeaseAction::Release: - return "release"; - default: - return std::string(); - } - } - - inline Models::PathLeaseAction PathLeaseActionFromString(const std::string& pathLeaseAction) - { - if (pathLeaseAction == "acquire") - { - return Models::PathLeaseAction::Acquire; - } - if (pathLeaseAction == "break") - { - return Models::PathLeaseAction::Break; - } - if (pathLeaseAction == "change") - { - return Models::PathLeaseAction::Change; - } - if (pathLeaseAction == "renew") - { - return Models::PathLeaseAction::Renew; - } - if (pathLeaseAction == "release") - { - return Models::PathLeaseAction::Release; - } - throw std::runtime_error("Cannot convert " + pathLeaseAction + " to PathLeaseAction"); - } - - inline std::string PathGetPropertiesActionToString( - const Models::PathGetPropertiesAction& pathGetPropertiesAction) - { - switch (pathGetPropertiesAction) - { - case Models::PathGetPropertiesAction::GetAccessControl: - return "getAccessControl"; - case Models::PathGetPropertiesAction::GetStatus: - return "getStatus"; - default: - return std::string(); - } - } - - inline Models::PathGetPropertiesAction PathGetPropertiesActionFromString( - const std::string& pathGetPropertiesAction) - { - if (pathGetPropertiesAction == "getAccessControl") - { - return Models::PathGetPropertiesAction::GetAccessControl; - } - if (pathGetPropertiesAction == "getStatus") - { - return Models::PathGetPropertiesAction::GetStatus; - } - throw std::runtime_error( - "Cannot convert " + pathGetPropertiesAction + " to PathGetPropertiesAction"); - } - - inline std::string LeaseStateTypeToString(const Models::LeaseStateType& leaseStateType) - { - switch (leaseStateType) - { - case Models::LeaseStateType::Available: - return "available"; - case Models::LeaseStateType::Leased: - return "leased"; - case Models::LeaseStateType::Expired: - return "expired"; - case Models::LeaseStateType::Breaking: - return "breaking"; - case Models::LeaseStateType::Broken: - return "broken"; - default: - return std::string(); - } - } - - inline Models::LeaseStateType LeaseStateTypeFromString(const std::string& leaseStateType) - { - if (leaseStateType == "available") - { - return Models::LeaseStateType::Available; - } - if (leaseStateType == "leased") - { - return Models::LeaseStateType::Leased; - } - if (leaseStateType == "expired") - { - return Models::LeaseStateType::Expired; - } - if (leaseStateType == "breaking") - { - return Models::LeaseStateType::Breaking; - } - if (leaseStateType == "broken") - { - return Models::LeaseStateType::Broken; - } - throw std::runtime_error("Cannot convert " + leaseStateType + " to LeaseStateType"); - } - - inline std::string LeaseStatusTypeToString(const Models::LeaseStatusType& leaseStatusType) - { - switch (leaseStatusType) - { - case Models::LeaseStatusType::Locked: - return "locked"; - case Models::LeaseStatusType::Unlocked: - return "unlocked"; - default: - return std::string(); - } - } - - inline Models::LeaseStatusType LeaseStatusTypeFromString(const std::string& leaseStatusType) - { - if (leaseStatusType == "locked") - { - return Models::LeaseStatusType::Locked; - } - if (leaseStatusType == "unlocked") - { - return Models::LeaseStatusType::Unlocked; - } - throw std::runtime_error("Cannot convert " + leaseStatusType + " to LeaseStatusType"); - } class DataLakeRestClient { public: @@ -805,7 +584,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { public: struct CreateOptions { - Models::FileSystemResourceType Resource = Models::FileSystemResourceType::Unknown; + Models::FileSystemResourceType Resource; Azure::Core::Nullable ClientRequestId; Azure::Core::Nullable Timeout; std::string ApiVersionParameter = Details::DefaultServiceApiVersion; @@ -822,8 +601,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { request.AddHeader(Details::HeaderContentLength, "0"); request.GetUrl().AppendQueryParameter( Details::QueryFileSystemResource, - Storage::Details::UrlEncodeQueryParameter( - FileSystemResourceTypeToString(createOptions.Resource))); + Storage::Details::UrlEncodeQueryParameter((createOptions.Resource.Get()))); if (createOptions.ClientRequestId.HasValue()) { request.AddHeader(Details::HeaderRequestId, createOptions.ClientRequestId.GetValue()); @@ -845,7 +623,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { struct SetPropertiesOptions { - Models::FileSystemResourceType Resource = Models::FileSystemResourceType::Unknown; + Models::FileSystemResourceType Resource; Azure::Core::Nullable ClientRequestId; Azure::Core::Nullable Timeout; std::string ApiVersionParameter = Details::DefaultServiceApiVersion; @@ -863,8 +641,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Patch, url); request.GetUrl().AppendQueryParameter( Details::QueryFileSystemResource, - Storage::Details::UrlEncodeQueryParameter( - FileSystemResourceTypeToString(setPropertiesOptions.Resource))); + Storage::Details::UrlEncodeQueryParameter((setPropertiesOptions.Resource.Get()))); if (setPropertiesOptions.ClientRequestId.HasValue()) { request.AddHeader( @@ -902,7 +679,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { struct GetPropertiesOptions { - Models::FileSystemResourceType Resource = Models::FileSystemResourceType::Unknown; + Models::FileSystemResourceType Resource; Azure::Core::Nullable ClientRequestId; Azure::Core::Nullable Timeout; std::string ApiVersionParameter = Details::DefaultServiceApiVersion; @@ -917,8 +694,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Head, url); request.GetUrl().AppendQueryParameter( Details::QueryFileSystemResource, - Storage::Details::UrlEncodeQueryParameter( - FileSystemResourceTypeToString(getPropertiesOptions.Resource))); + Storage::Details::UrlEncodeQueryParameter((getPropertiesOptions.Resource.Get()))); if (getPropertiesOptions.ClientRequestId.HasValue()) { request.AddHeader( @@ -937,7 +713,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { struct DeleteOptions { - Models::FileSystemResourceType Resource = Models::FileSystemResourceType::Unknown; + Models::FileSystemResourceType Resource; Azure::Core::Nullable ClientRequestId; Azure::Core::Nullable Timeout; std::string ApiVersionParameter = Details::DefaultServiceApiVersion; @@ -954,8 +730,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Delete, url); request.GetUrl().AppendQueryParameter( Details::QueryFileSystemResource, - Storage::Details::UrlEncodeQueryParameter( - FileSystemResourceTypeToString(deleteOptions.Resource))); + Storage::Details::UrlEncodeQueryParameter((deleteOptions.Resource.Get()))); if (deleteOptions.ClientRequestId.HasValue()) { request.AddHeader(Details::HeaderRequestId, deleteOptions.ClientRequestId.GetValue()); @@ -987,7 +762,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { struct ListPathsOptions { - Models::FileSystemResourceType Resource = Models::FileSystemResourceType::Unknown; + Models::FileSystemResourceType Resource; Azure::Core::Nullable ClientRequestId; Azure::Core::Nullable Timeout; std::string ApiVersionParameter = Details::DefaultServiceApiVersion; @@ -1007,8 +782,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url); request.GetUrl().AppendQueryParameter( Details::QueryFileSystemResource, - Storage::Details::UrlEncodeQueryParameter( - FileSystemResourceTypeToString(listPathsOptions.Resource))); + Storage::Details::UrlEncodeQueryParameter((listPathsOptions.Resource.Get()))); if (listPathsOptions.ClientRequestId.HasValue()) { request.AddHeader( @@ -1275,7 +1049,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { request.GetUrl().AppendQueryParameter( Details::QueryPathResourceType, Storage::Details::UrlEncodeQueryParameter( - PathResourceTypeToString(createOptions.Resource.GetValue()))); + (createOptions.Resource.GetValue().Get()))); } if (createOptions.ContinuationToken.HasValue()) { @@ -1288,8 +1062,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { { request.GetUrl().AppendQueryParameter( Details::QueryPathRenameMode, - Storage::Details::UrlEncodeQueryParameter( - PathRenameModeToString(createOptions.Mode.GetValue()))); + Storage::Details::UrlEncodeQueryParameter((createOptions.Mode.GetValue().Get()))); } if (createOptions.CacheControl.HasValue()) { @@ -1391,7 +1164,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { Azure::Core::Nullable ClientRequestId; Azure::Core::Nullable Timeout; std::string ApiVersionParameter = Details::DefaultServiceApiVersion; - Models::PathLeaseAction XMsLeaseAction = Models::PathLeaseAction::Unknown; + Models::PathLeaseAction XMsLeaseAction; Azure::Core::Nullable XMsLeaseDuration; Azure::Core::Nullable XMsLeaseBreakPeriod; Azure::Core::Nullable LeaseIdOptional; @@ -1422,8 +1195,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { std::to_string(leaseOptions.Timeout.GetValue()))); } request.AddHeader(Details::HeaderVersion, leaseOptions.ApiVersionParameter); - request.AddHeader( - Details::HeaderPathLeaseAction, PathLeaseActionToString(leaseOptions.XMsLeaseAction)); + request.AddHeader(Details::HeaderPathLeaseAction, (leaseOptions.XMsLeaseAction.Get())); if (leaseOptions.XMsLeaseDuration.HasValue()) { request.AddHeader( @@ -1509,7 +1281,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { request.GetUrl().AppendQueryParameter( Details::QueryPathGetPropertiesAction, Storage::Details::UrlEncodeQueryParameter( - PathGetPropertiesActionToString(getPropertiesOptions.Action.GetValue()))); + (getPropertiesOptions.Action.GetValue().Get()))); } if (getPropertiesOptions.Upn.HasValue()) { @@ -1714,8 +1486,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { { Azure::Core::Nullable Timeout; Azure::Core::Nullable ContinuationToken; - Models::PathSetAccessControlRecursiveMode Mode - = Models::PathSetAccessControlRecursiveMode::Unknown; + Models::PathSetAccessControlRecursiveMode Mode; Azure::Core::Nullable ForceFlag; Azure::Core::Nullable MaxRecords; Azure::Core::Nullable Acl; @@ -1748,8 +1519,8 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { } request.GetUrl().AppendQueryParameter( Details::QueryPathSetAccessControlRecursiveMode, - Storage::Details::UrlEncodeQueryParameter(PathSetAccessControlRecursiveModeToString( - setAccessControlRecursiveOptions.Mode))); + Storage::Details::UrlEncodeQueryParameter( + (setAccessControlRecursiveOptions.Mode.Get()))); if (setAccessControlRecursiveOptions.ForceFlag.HasValue()) { request.GetUrl().AppendQueryParameter( @@ -1982,7 +1753,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { Azure::Core::Nullable Timeout; std::string ApiVersionParameter = Details::DefaultServiceApiVersion; Azure::Core::Nullable ClientRequestId; - Models::PathExpiryOptions XMsExpiryOption = Models::PathExpiryOptions::Unknown; + Models::PathExpiryOptions XMsExpiryOption; Azure::Core::Nullable PathExpiryTime; }; @@ -2008,9 +1779,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { request.AddHeader( Details::HeaderRequestId, setExpiryOptions.ClientRequestId.GetValue()); } - request.AddHeader( - Details::HeaderExpiryOptions, - PathExpiryOptionsToString(setExpiryOptions.XMsExpiryOption)); + request.AddHeader(Details::HeaderExpiryOptions, (setExpiryOptions.XMsExpiryOption.Get())); if (setExpiryOptions.PathExpiryTime.HasValue()) { request.AddHeader(Details::HeaderExpiresOn, setExpiryOptions.PathExpiryTime.GetValue()); @@ -2206,13 +1975,13 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { != response.GetHeaders().end()) { result.LeaseState - = LeaseStateTypeFromString(response.GetHeaders().at(Details::HeaderLeaseState)); + = Models::LeaseStateType(response.GetHeaders().at(Details::HeaderLeaseState)); } if (response.GetHeaders().find(Details::HeaderLeaseStatus) != response.GetHeaders().end()) { result.LeaseStatus - = LeaseStatusTypeFromString(response.GetHeaders().at(Details::HeaderLeaseStatus)); + = Models::LeaseStatusType(response.GetHeaders().at(Details::HeaderLeaseStatus)); } return Azure::Core::Response( std::move(result), std::move(responsePtr)); diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp index d715e9d71..b65635a17 100644 --- a/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp +++ b/sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp @@ -66,7 +66,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { { return Models::LeaseStateType::Leased; } - return Models::LeaseStateType::Unknown; + return Models::LeaseStateType(); } Models::LeaseStatusType FromBlobLeaseStatus(Blobs::Models::BlobLeaseStatus status) @@ -79,7 +79,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { { return Models::LeaseStatusType::Unlocked; } - return Models::LeaseStatusType::Unknown; + return Models::LeaseStatusType(); } } // namespace diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp index 61b15f4cb..82220c12f 100644 --- a/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp +++ b/sdk/storage/azure-storage-files-datalake/src/datalake_path_client.cpp @@ -55,7 +55,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { { return Models::LeaseStateType::Leased; } - return Models::LeaseStateType::Unknown; + return Models::LeaseStateType(); } Models::LeaseStatusType FromBlobLeaseStatus(Blobs::Models::BlobLeaseStatus status) @@ -68,7 +68,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake { { return Models::LeaseStatusType::Unlocked; } - return Models::LeaseStatusType::Unknown; + return Models::LeaseStatusType(); } } // namespace diff --git a/sdk/storage/azure-storage-files-datalake/src/datalake_rest_client.cpp b/sdk/storage/azure-storage-files-datalake/src/datalake_rest_client.cpp new file mode 100644 index 000000000..80e6e6530 --- /dev/null +++ b/sdk/storage/azure-storage-files-datalake/src/datalake_rest_client.cpp @@ -0,0 +1,45 @@ + +// Copyright (c) Microsoft Corporation. All rights reserved. +// SPDX-License-Identifier: MIT + +#include "azure/storage/files/datalake/protocol/datalake_rest_client.hpp" + +namespace Azure { namespace Storage { namespace Files { namespace DataLake { namespace Models { + const FileSystemResourceType FileSystemResourceType::Filesystem("filesystem"); + + const PathSetAccessControlRecursiveMode PathSetAccessControlRecursiveMode::Set("set"); + const PathSetAccessControlRecursiveMode PathSetAccessControlRecursiveMode::Modify("modify"); + const PathSetAccessControlRecursiveMode PathSetAccessControlRecursiveMode::Remove("remove"); + + const PathExpiryOptions PathExpiryOptions::NeverExpire("NeverExpire"); + const PathExpiryOptions PathExpiryOptions::RelativeToCreation("RelativeToCreation"); + const PathExpiryOptions PathExpiryOptions::RelativeToNow("RelativeToNow"); + const PathExpiryOptions PathExpiryOptions::Absolute("Absolute"); + + const AccountResourceType AccountResourceType::Account("account"); + + const PathResourceType PathResourceType::Directory("directory"); + const PathResourceType PathResourceType::File("file"); + + const PathRenameMode PathRenameMode::Legacy("legacy"); + const PathRenameMode PathRenameMode::Posix("posix"); + + const PathLeaseAction PathLeaseAction::Acquire("acquire"); + const PathLeaseAction PathLeaseAction::Break("break"); + const PathLeaseAction PathLeaseAction::Change("change"); + const PathLeaseAction PathLeaseAction::Renew("renew"); + const PathLeaseAction PathLeaseAction::Release("release"); + + const PathGetPropertiesAction PathGetPropertiesAction::GetAccessControl("getAccessControl"); + const PathGetPropertiesAction PathGetPropertiesAction::GetStatus("getStatus"); + + const LeaseStateType LeaseStateType::Available("available"); + const LeaseStateType LeaseStateType::Leased("leased"); + const LeaseStateType LeaseStateType::Expired("expired"); + const LeaseStateType LeaseStateType::Breaking("breaking"); + const LeaseStateType LeaseStateType::Broken("broken"); + + const LeaseStatusType LeaseStatusType::Locked("locked"); + const LeaseStatusType LeaseStatusType::Unlocked("unlocked"); + +}}}}} // namespace Azure::Storage::Files::DataLake::Models diff --git a/sdk/storage/azure-storage-files-shares/CHANGELOG.md b/sdk/storage/azure-storage-files-shares/CHANGELOG.md index c80542723..0e3afd2d7 100644 --- a/sdk/storage/azure-storage-files-shares/CHANGELOG.md +++ b/sdk/storage/azure-storage-files-shares/CHANGELOG.md @@ -19,6 +19,7 @@ - Renamed all functions and structures that could retrieve partial query results from the server to have `SinglePage` suffix instead of `Segment` suffix. - Removed `FileRange` and `ClearRange`, they are now represented with `Azure::Core::Http::Range`. - Removed `Offset` and `Length` pair in options. They are now represented with `Azure::Core::Http::Range`. +- Replace scoped enums that don't support bitwise operations with extensible enum. ## 12.0.0-beta.5 (2020-11-13) diff --git a/sdk/storage/azure-storage-files-shares/CMakeLists.txt b/sdk/storage/azure-storage-files-shares/CMakeLists.txt index 3f2bf2643..338d146cb 100644 --- a/sdk/storage/azure-storage-files-shares/CMakeLists.txt +++ b/sdk/storage/azure-storage-files-shares/CMakeLists.txt @@ -47,6 +47,7 @@ set( src/share_client.cpp src/share_directory_client.cpp src/share_file_client.cpp + src/share_rest_client.cpp src/share_sas_builder.cpp src/share_service_client.cpp ) diff --git a/sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/protocol/share_rest_client.hpp b/sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/protocol/share_rest_client.hpp index 24bb25a77..28b149975 100644 --- a/sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/protocol/share_rest_client.hpp +++ b/sdk/storage/azure-storage-files-shares/inc/azure/storage/files/shares/protocol/share_rest_client.hpp @@ -134,30 +134,64 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { std::string ContentType; Storage::ContentHash ContentHash; }; + // Specifies the option to copy file security descriptor from source file or to set it using the // value which is defined by the header value of x-ms-file-permission or // x-ms-file-permission-key. - enum class PermissionCopyModeType - { - Source, - Override, - Unknown - }; + class PermissionCopyModeType { + public: + PermissionCopyModeType() = default; + explicit PermissionCopyModeType(std::string value) : m_value(std::move(value)) {} + bool operator==(const PermissionCopyModeType& other) const + { + return m_value == other.m_value; + } + bool operator!=(const PermissionCopyModeType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static PermissionCopyModeType Source; + const static PermissionCopyModeType Override; + + private: + std::string m_value; + }; // extensible enum PermissionCopyModeType // Specifies the option include to delete the base share and all of its snapshots. - enum class DeleteSnapshotsOptionType - { - Include, - Unknown - }; + class DeleteSnapshotsOptionType { + public: + DeleteSnapshotsOptionType() = default; + explicit DeleteSnapshotsOptionType(std::string value) : m_value(std::move(value)) {} + bool operator==(const DeleteSnapshotsOptionType& other) const + { + return m_value == other.m_value; + } + bool operator!=(const DeleteSnapshotsOptionType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static DeleteSnapshotsOptionType Include; + + private: + std::string m_value; + }; // extensible enum DeleteSnapshotsOptionType // Only update is supported: - Update: Writes the bytes downloaded from the source url into the // specified range. - enum class FileRangeWriteFromUrlType - { - Update, - Unknown - }; + class FileRangeWriteFromUrlType { + public: + FileRangeWriteFromUrlType() = default; + explicit FileRangeWriteFromUrlType(std::string value) : m_value(std::move(value)) {} + bool operator==(const FileRangeWriteFromUrlType& other) const + { + return m_value == other.m_value; + } + bool operator!=(const FileRangeWriteFromUrlType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static FileRangeWriteFromUrlType Update; + + private: + std::string m_value; + }; // extensible enum FileRangeWriteFromUrlType // An Access policy. struct AccessPolicy @@ -234,31 +268,55 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { }; // When a file or share is leased, specifies whether the lease is of infinite or fixed duration. - enum class LeaseDurationType - { - Infinite, - Fixed, - Unknown - }; + class LeaseDurationType { + public: + LeaseDurationType() = default; + explicit LeaseDurationType(std::string value) : m_value(std::move(value)) {} + bool operator==(const LeaseDurationType& other) const { return m_value == other.m_value; } + bool operator!=(const LeaseDurationType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static LeaseDurationType Infinite; + const static LeaseDurationType Fixed; + + private: + std::string m_value; + }; // extensible enum LeaseDurationType // Lease state of the file or share. - enum class LeaseStateType - { - Available, - Leased, - Expired, - Breaking, - Broken, - Unknown - }; + class LeaseStateType { + public: + LeaseStateType() = default; + explicit LeaseStateType(std::string value) : m_value(std::move(value)) {} + bool operator==(const LeaseStateType& other) const { return m_value == other.m_value; } + bool operator!=(const LeaseStateType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static LeaseStateType Available; + const static LeaseStateType Leased; + const static LeaseStateType Expired; + const static LeaseStateType Breaking; + const static LeaseStateType Broken; + + private: + std::string m_value; + }; // extensible enum LeaseStateType // The current lease status of the file or share. - enum class LeaseStatusType - { - Locked, - Unlocked, - Unknown - }; + class LeaseStatusType { + public: + LeaseStatusType() = default; + explicit LeaseStatusType(std::string value) : m_value(std::move(value)) {} + bool operator==(const LeaseStatusType& other) const { return m_value == other.m_value; } + bool operator!=(const LeaseStatusType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static LeaseStatusType Locked; + const static LeaseStatusType Unlocked; + + private: + std::string m_value; + }; // extensible enum LeaseStatusType // An enumeration of directories and files. struct ListFilesAndDirectoriesSinglePageResponse @@ -293,9 +351,9 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { Azure::Core::Nullable NextAllowedQuotaDowngradeTime; Azure::Core::Nullable DeletedOn; int32_t RemainingRetentionDays = int32_t(); - Models::LeaseStatusType LeaseStatus = Models::LeaseStatusType::Unknown; - Models::LeaseStateType LeaseState = Models::LeaseStateType::Unknown; - Models::LeaseDurationType LeaseDuration = Models::LeaseDurationType::Unknown; + Models::LeaseStatusType LeaseStatus; + Models::LeaseStateType LeaseState; + Models::LeaseDurationType LeaseDuration; }; // A listed Azure Storage share item. @@ -415,37 +473,61 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { }; // Describes what lease action to take. - enum class LeaseAction - { - Acquire, - Release, - Change, - Renew, - Break, - Unknown - }; + class LeaseAction { + public: + LeaseAction() = default; + explicit LeaseAction(std::string value) : m_value(std::move(value)) {} + bool operator==(const LeaseAction& other) const { return m_value == other.m_value; } + bool operator!=(const LeaseAction& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static LeaseAction Acquire; + const static LeaseAction Release; + const static LeaseAction Change; + const static LeaseAction Renew; + const static LeaseAction Break; + + private: + std::string m_value; + }; // extensible enum LeaseAction // State of the copy operation identified by 'x-ms-copy-id'. - enum class CopyStatusType - { - Pending, - Success, - Aborted, - Failed, - Unknown - }; + class CopyStatusType { + public: + CopyStatusType() = default; + explicit CopyStatusType(std::string value) : m_value(std::move(value)) {} + bool operator==(const CopyStatusType& other) const { return m_value == other.m_value; } + bool operator!=(const CopyStatusType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static CopyStatusType Pending; + const static CopyStatusType Success; + const static CopyStatusType Aborted; + const static CopyStatusType Failed; + + private: + std::string m_value; + }; // extensible enum CopyStatusType // Specify one of the following options: - Update: Writes the bytes specified by the request // body into the specified range. The Range and Content-Length headers must match to perform the // update. - Clear: Clears the specified range and releases the space used in storage for that // range. To clear a range, set the Content-Length header to zero, and set the Range header to a // value that indicates the range to clear, up to maximum file size. - enum class FileRangeWriteType - { - Update, - Clear, - Unknown - }; + class FileRangeWriteType { + public: + FileRangeWriteType() = default; + explicit FileRangeWriteType(std::string value) : m_value(std::move(value)) {} + bool operator==(const FileRangeWriteType& other) const { return m_value == other.m_value; } + bool operator!=(const FileRangeWriteType& other) const { return !(*this == other); } + const std::string& Get() const { return m_value; } + + const static FileRangeWriteType Update; + const static FileRangeWriteType Clear; + + private: + std::string m_value; + }; // extensible enum FileRangeWriteType struct ServiceSetPropertiesResult { @@ -821,7 +903,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { std::string ETag; Core::DateTime LastModified; std::string CopyId; - CopyStatusType CopyStatus = CopyStatusType::Unknown; + CopyStatusType CopyStatus; }; struct FileAbortCopyResult @@ -903,287 +985,6 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { } // namespace Models namespace Details { - inline std::string PermissionCopyModeTypeToString( - const Models::PermissionCopyModeType& permissionCopyModeType) - { - switch (permissionCopyModeType) - { - case Models::PermissionCopyModeType::Source: - return "source"; - case Models::PermissionCopyModeType::Override: - return "override"; - default: - return std::string(); - } - } - - inline Models::PermissionCopyModeType PermissionCopyModeTypeFromString( - const std::string& permissionCopyModeType) - { - if (permissionCopyModeType == "source") - { - return Models::PermissionCopyModeType::Source; - } - if (permissionCopyModeType == "override") - { - return Models::PermissionCopyModeType::Override; - } - throw std::runtime_error( - "Cannot convert " + permissionCopyModeType + " to PermissionCopyModeType"); - } - - inline std::string DeleteSnapshotsOptionTypeToString( - const Models::DeleteSnapshotsOptionType& deleteSnapshotsOptionType) - { - switch (deleteSnapshotsOptionType) - { - case Models::DeleteSnapshotsOptionType::Include: - return "include"; - default: - return std::string(); - } - } - - inline Models::DeleteSnapshotsOptionType DeleteSnapshotsOptionTypeFromString( - const std::string& deleteSnapshotsOptionType) - { - if (deleteSnapshotsOptionType == "include") - { - return Models::DeleteSnapshotsOptionType::Include; - } - throw std::runtime_error( - "Cannot convert " + deleteSnapshotsOptionType + " to DeleteSnapshotsOptionType"); - } - - inline std::string FileRangeWriteFromUrlTypeToString( - const Models::FileRangeWriteFromUrlType& fileRangeWriteFromUrlType) - { - switch (fileRangeWriteFromUrlType) - { - case Models::FileRangeWriteFromUrlType::Update: - return "update"; - default: - return std::string(); - } - } - - inline Models::FileRangeWriteFromUrlType FileRangeWriteFromUrlTypeFromString( - const std::string& fileRangeWriteFromUrlType) - { - if (fileRangeWriteFromUrlType == "update") - { - return Models::FileRangeWriteFromUrlType::Update; - } - throw std::runtime_error( - "Cannot convert " + fileRangeWriteFromUrlType + " to FileRangeWriteFromUrlType"); - } - - inline std::string LeaseDurationTypeToString(const Models::LeaseDurationType& leaseDurationType) - { - switch (leaseDurationType) - { - case Models::LeaseDurationType::Infinite: - return "infinite"; - case Models::LeaseDurationType::Fixed: - return "fixed"; - default: - return std::string(); - } - } - - inline Models::LeaseDurationType LeaseDurationTypeFromString( - const std::string& leaseDurationType) - { - if (leaseDurationType == "infinite") - { - return Models::LeaseDurationType::Infinite; - } - if (leaseDurationType == "fixed") - { - return Models::LeaseDurationType::Fixed; - } - throw std::runtime_error("Cannot convert " + leaseDurationType + " to LeaseDurationType"); - } - - inline std::string LeaseStateTypeToString(const Models::LeaseStateType& leaseStateType) - { - switch (leaseStateType) - { - case Models::LeaseStateType::Available: - return "available"; - case Models::LeaseStateType::Leased: - return "leased"; - case Models::LeaseStateType::Expired: - return "expired"; - case Models::LeaseStateType::Breaking: - return "breaking"; - case Models::LeaseStateType::Broken: - return "broken"; - default: - return std::string(); - } - } - - inline Models::LeaseStateType LeaseStateTypeFromString(const std::string& leaseStateType) - { - if (leaseStateType == "available") - { - return Models::LeaseStateType::Available; - } - if (leaseStateType == "leased") - { - return Models::LeaseStateType::Leased; - } - if (leaseStateType == "expired") - { - return Models::LeaseStateType::Expired; - } - if (leaseStateType == "breaking") - { - return Models::LeaseStateType::Breaking; - } - if (leaseStateType == "broken") - { - return Models::LeaseStateType::Broken; - } - throw std::runtime_error("Cannot convert " + leaseStateType + " to LeaseStateType"); - } - - inline std::string LeaseStatusTypeToString(const Models::LeaseStatusType& leaseStatusType) - { - switch (leaseStatusType) - { - case Models::LeaseStatusType::Locked: - return "locked"; - case Models::LeaseStatusType::Unlocked: - return "unlocked"; - default: - return std::string(); - } - } - - inline Models::LeaseStatusType LeaseStatusTypeFromString(const std::string& leaseStatusType) - { - if (leaseStatusType == "locked") - { - return Models::LeaseStatusType::Locked; - } - if (leaseStatusType == "unlocked") - { - return Models::LeaseStatusType::Unlocked; - } - throw std::runtime_error("Cannot convert " + leaseStatusType + " to LeaseStatusType"); - } - - inline std::string LeaseActionToString(const Models::LeaseAction& leaseAction) - { - switch (leaseAction) - { - case Models::LeaseAction::Acquire: - return "acquire"; - case Models::LeaseAction::Release: - return "release"; - case Models::LeaseAction::Change: - return "change"; - case Models::LeaseAction::Renew: - return "renew"; - case Models::LeaseAction::Break: - return "break"; - default: - return std::string(); - } - } - - inline Models::LeaseAction LeaseActionFromString(const std::string& leaseAction) - { - if (leaseAction == "acquire") - { - return Models::LeaseAction::Acquire; - } - if (leaseAction == "release") - { - return Models::LeaseAction::Release; - } - if (leaseAction == "change") - { - return Models::LeaseAction::Change; - } - if (leaseAction == "renew") - { - return Models::LeaseAction::Renew; - } - if (leaseAction == "break") - { - return Models::LeaseAction::Break; - } - throw std::runtime_error("Cannot convert " + leaseAction + " to LeaseAction"); - } - - inline std::string CopyStatusTypeToString(const Models::CopyStatusType& copyStatusType) - { - switch (copyStatusType) - { - case Models::CopyStatusType::Pending: - return "pending"; - case Models::CopyStatusType::Success: - return "success"; - case Models::CopyStatusType::Aborted: - return "aborted"; - case Models::CopyStatusType::Failed: - return "failed"; - default: - return std::string(); - } - } - - inline Models::CopyStatusType CopyStatusTypeFromString(const std::string& copyStatusType) - { - if (copyStatusType == "pending") - { - return Models::CopyStatusType::Pending; - } - if (copyStatusType == "success") - { - return Models::CopyStatusType::Success; - } - if (copyStatusType == "aborted") - { - return Models::CopyStatusType::Aborted; - } - if (copyStatusType == "failed") - { - return Models::CopyStatusType::Failed; - } - throw std::runtime_error("Cannot convert " + copyStatusType + " to CopyStatusType"); - } - - inline std::string FileRangeWriteTypeToString( - const Models::FileRangeWriteType& fileRangeWriteType) - { - switch (fileRangeWriteType) - { - case Models::FileRangeWriteType::Update: - return "update"; - case Models::FileRangeWriteType::Clear: - return "clear"; - default: - return std::string(); - } - } - - inline Models::FileRangeWriteType FileRangeWriteTypeFromString( - const std::string& fileRangeWriteType) - { - if (fileRangeWriteType == "update") - { - return Models::FileRangeWriteType::Update; - } - if (fileRangeWriteType == "clear") - { - return Models::FileRangeWriteType::Clear; - } - throw std::runtime_error("Cannot convert " + fileRangeWriteType + " to FileRangeWriteType"); - } class ShareRestClient { private: @@ -2087,7 +1888,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { static Models::LeaseStatusType LeaseStatusTypeFromXml(Storage::Details::XmlReader& reader) { - auto result = Models::LeaseStatusType::Unknown; + Models::LeaseStatusType result; enum class XmlTagName { LeaseStatus, @@ -2129,7 +1930,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { { if (path.size() == 1 && path[0] == XmlTagName::LeaseStatus) { - result = LeaseStatusTypeFromString(node.Value); + result = Models::LeaseStatusType(node.Value); } } } @@ -2138,7 +1939,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { static Models::LeaseStateType LeaseStateTypeFromXml(Storage::Details::XmlReader& reader) { - auto result = Models::LeaseStateType::Unknown; + Models::LeaseStateType result; enum class XmlTagName { LeaseState, @@ -2180,7 +1981,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { { if (path.size() == 1 && path[0] == XmlTagName::LeaseState) { - result = LeaseStateTypeFromString(node.Value); + result = Models::LeaseStateType(node.Value); } } } @@ -2190,7 +1991,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { static Models::LeaseDurationType LeaseDurationTypeFromXml( Storage::Details::XmlReader& reader) { - auto result = Models::LeaseDurationType::Unknown; + Models::LeaseDurationType result; enum class XmlTagName { LeaseDuration, @@ -2232,7 +2033,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { { if (path.size() == 1 && path[0] == XmlTagName::LeaseDuration) { - result = LeaseDurationTypeFromString(node.Value); + result = Models::LeaseDurationType(node.Value); } } } @@ -2772,7 +2573,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { { request.AddHeader( Details::HeaderDeleteSnapshots, - DeleteSnapshotsOptionTypeToString(deleteOptions.XMsDeleteSnapshots.GetValue())); + (deleteOptions.XMsDeleteSnapshots.GetValue().Get())); } if (deleteOptions.LeaseIdOptional.HasValue()) { @@ -3426,20 +3227,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { if (response.GetHeaders().find(Details::HeaderLeaseDuration) != response.GetHeaders().end()) { - result.LeaseDuration = LeaseDurationTypeFromString( + result.LeaseDuration = Models::LeaseDurationType( response.GetHeaders().at(Details::HeaderLeaseDuration)); } if (response.GetHeaders().find(Details::HeaderLeaseState) != response.GetHeaders().end()) { result.LeaseState - = LeaseStateTypeFromString(response.GetHeaders().at(Details::HeaderLeaseState)); + = Models::LeaseStateType(response.GetHeaders().at(Details::HeaderLeaseState)); } if (response.GetHeaders().find(Details::HeaderLeaseStatus) != response.GetHeaders().end()) { result.LeaseStatus - = LeaseStatusTypeFromString(response.GetHeaders().at(Details::HeaderLeaseStatus)); + = Models::LeaseStatusType(response.GetHeaders().at(Details::HeaderLeaseStatus)); } return Azure::Core::Response( std::move(result), std::move(responsePtr)); @@ -5851,7 +5652,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { { Azure::Core::Nullable Timeout; std::string XMsRange; - Models::FileRangeWriteType XMsWrite = Models::FileRangeWriteType::Unknown; + Models::FileRangeWriteType XMsWrite; int64_t ContentLength = int64_t(); Azure::Core::Nullable ContentMd5; std::string ApiVersionParameter = Details::DefaultServiceApiVersion; @@ -5875,9 +5676,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { std::to_string(uploadRangeOptions.Timeout.GetValue()))); } request.AddHeader(Details::HeaderXMsRange, uploadRangeOptions.XMsRange); - request.AddHeader( - Details::HeaderFileRangeWrite, - FileRangeWriteTypeToString(uploadRangeOptions.XMsWrite)); + request.AddHeader(Details::HeaderFileRangeWrite, (uploadRangeOptions.XMsWrite.Get())); request.AddHeader( Details::HeaderContentLength, std::to_string(uploadRangeOptions.ContentLength)); if (uploadRangeOptions.ContentMd5.HasValue()) @@ -5901,7 +5700,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { std::string TargetRange; std::string CopySource; Azure::Core::Nullable SourceRange; - Models::FileRangeWriteFromUrlType XMsWrite = Models::FileRangeWriteFromUrlType::Unknown; + Models::FileRangeWriteFromUrlType XMsWrite; int64_t ContentLength = int64_t(); Azure::Core::Nullable SourceContentCrc64; Azure::Core::Nullable SourceIfMatchCrc64; @@ -5934,8 +5733,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { Details::HeaderSourceRange, uploadRangeFromUrlOptions.SourceRange.GetValue()); } request.AddHeader( - Details::HeaderFileRangeWriteFromUrl, - FileRangeWriteFromUrlTypeToString(uploadRangeFromUrlOptions.XMsWrite)); + Details::HeaderFileRangeWriteFromUrl, (uploadRangeFromUrlOptions.XMsWrite.Get())); request.AddHeader( Details::HeaderContentLength, std::to_string(uploadRangeFromUrlOptions.ContentLength)); @@ -6073,8 +5871,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { { request.AddHeader( Details::HeaderFilePermissionCopyMode, - PermissionCopyModeTypeToString( - startCopyOptions.XMsFilePermissionCopyMode.GetValue())); + (startCopyOptions.XMsFilePermissionCopyMode.GetValue().Get())); } if (startCopyOptions.FileCopyIgnoreReadOnly.HasValue()) { @@ -6372,7 +6169,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { != response.GetHeaders().end()) { result.CopyStatus - = CopyStatusTypeFromString(response.GetHeaders().at(Details::HeaderCopyStatus)); + = Models::CopyStatusType(response.GetHeaders().at(Details::HeaderCopyStatus)); } if (response.GetHeaders().find(Details::HeaderContentHashMd5) != response.GetHeaders().end()) @@ -6402,20 +6199,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { if (response.GetHeaders().find(Details::HeaderLeaseDuration) != response.GetHeaders().end()) { - result.LeaseDuration = LeaseDurationTypeFromString( + result.LeaseDuration = Models::LeaseDurationType( response.GetHeaders().at(Details::HeaderLeaseDuration)); } if (response.GetHeaders().find(Details::HeaderLeaseState) != response.GetHeaders().end()) { result.LeaseState - = LeaseStateTypeFromString(response.GetHeaders().at(Details::HeaderLeaseState)); + = Models::LeaseStateType(response.GetHeaders().at(Details::HeaderLeaseState)); } if (response.GetHeaders().find(Details::HeaderLeaseStatus) != response.GetHeaders().end()) { result.LeaseStatus - = LeaseStatusTypeFromString(response.GetHeaders().at(Details::HeaderLeaseStatus)); + = Models::LeaseStatusType(response.GetHeaders().at(Details::HeaderLeaseStatus)); } return Azure::Core::Response( std::move(result), std::move(responsePtr)); @@ -6508,7 +6305,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { != response.GetHeaders().end()) { result.CopyStatus - = CopyStatusTypeFromString(response.GetHeaders().at(Details::HeaderCopyStatus)); + = Models::CopyStatusType(response.GetHeaders().at(Details::HeaderCopyStatus)); } if (response.GetHeaders().find(Details::HeaderContentHashMd5) != response.GetHeaders().end()) @@ -6538,20 +6335,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { if (response.GetHeaders().find(Details::HeaderLeaseDuration) != response.GetHeaders().end()) { - result.LeaseDuration = LeaseDurationTypeFromString( + result.LeaseDuration = Models::LeaseDurationType( response.GetHeaders().at(Details::HeaderLeaseDuration)); } if (response.GetHeaders().find(Details::HeaderLeaseState) != response.GetHeaders().end()) { result.LeaseState - = LeaseStateTypeFromString(response.GetHeaders().at(Details::HeaderLeaseState)); + = Models::LeaseStateType(response.GetHeaders().at(Details::HeaderLeaseState)); } if (response.GetHeaders().find(Details::HeaderLeaseStatus) != response.GetHeaders().end()) { result.LeaseStatus - = LeaseStatusTypeFromString(response.GetHeaders().at(Details::HeaderLeaseStatus)); + = Models::LeaseStatusType(response.GetHeaders().at(Details::HeaderLeaseStatus)); } return Azure::Core::Response( std::move(result), std::move(responsePtr)); @@ -6654,7 +6451,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { != response.GetHeaders().end()) { result.CopyStatus - = CopyStatusTypeFromString(response.GetHeaders().at(Details::HeaderCopyStatus)); + = Models::CopyStatusType(response.GetHeaders().at(Details::HeaderCopyStatus)); } if (response.GetHeaders().find(Details::HeaderIsServerEncrypted) != response.GetHeaders().end()) @@ -6678,20 +6475,20 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { if (response.GetHeaders().find(Details::HeaderLeaseDuration) != response.GetHeaders().end()) { - result.LeaseDuration = LeaseDurationTypeFromString( + result.LeaseDuration = Models::LeaseDurationType( response.GetHeaders().at(Details::HeaderLeaseDuration)); } if (response.GetHeaders().find(Details::HeaderLeaseState) != response.GetHeaders().end()) { result.LeaseState - = LeaseStateTypeFromString(response.GetHeaders().at(Details::HeaderLeaseState)); + = Models::LeaseStateType(response.GetHeaders().at(Details::HeaderLeaseState)); } if (response.GetHeaders().find(Details::HeaderLeaseStatus) != response.GetHeaders().end()) { result.LeaseStatus - = LeaseStatusTypeFromString(response.GetHeaders().at(Details::HeaderLeaseStatus)); + = Models::LeaseStatusType(response.GetHeaders().at(Details::HeaderLeaseStatus)); } return Azure::Core::Response( std::move(result), std::move(responsePtr)); @@ -7075,7 +6872,7 @@ namespace Azure { namespace Storage { namespace Files { namespace Shares { != response.GetHeaders().end()) { result.CopyStatus - = CopyStatusTypeFromString(response.GetHeaders().at(Details::HeaderCopyStatus)); + = Models::CopyStatusType(response.GetHeaders().at(Details::HeaderCopyStatus)); } return Azure::Core::Response( std::move(result), std::move(responsePtr)); diff --git a/sdk/storage/azure-storage-files-shares/src/share_rest_client.cpp b/sdk/storage/azure-storage-files-shares/src/share_rest_client.cpp new file mode 100644 index 000000000..2b4bede8c --- /dev/null +++ b/sdk/storage/azure-storage-files-shares/src/share_rest_client.cpp @@ -0,0 +1,41 @@ + +// Copyright (c) Microsoft Corporation. All rights reserved. +// SPDX-License-Identifier: MIT + +#include "azure/storage/files/shares/protocol/share_rest_client.hpp" + +namespace Azure { namespace Storage { namespace Files { namespace Shares { namespace Models { + const PermissionCopyModeType PermissionCopyModeType::Source("source"); + const PermissionCopyModeType PermissionCopyModeType::Override("override"); + + const DeleteSnapshotsOptionType DeleteSnapshotsOptionType::Include("include"); + + const FileRangeWriteFromUrlType FileRangeWriteFromUrlType::Update("update"); + + const LeaseDurationType LeaseDurationType::Infinite("infinite"); + const LeaseDurationType LeaseDurationType::Fixed("fixed"); + + const LeaseStateType LeaseStateType::Available("available"); + const LeaseStateType LeaseStateType::Leased("leased"); + const LeaseStateType LeaseStateType::Expired("expired"); + const LeaseStateType LeaseStateType::Breaking("breaking"); + const LeaseStateType LeaseStateType::Broken("broken"); + + const LeaseStatusType LeaseStatusType::Locked("locked"); + const LeaseStatusType LeaseStatusType::Unlocked("unlocked"); + + const LeaseAction LeaseAction::Acquire("acquire"); + const LeaseAction LeaseAction::Release("release"); + const LeaseAction LeaseAction::Change("change"); + const LeaseAction LeaseAction::Renew("renew"); + const LeaseAction LeaseAction::Break("break"); + + const CopyStatusType CopyStatusType::Pending("pending"); + const CopyStatusType CopyStatusType::Success("success"); + const CopyStatusType CopyStatusType::Aborted("aborted"); + const CopyStatusType CopyStatusType::Failed("failed"); + + const FileRangeWriteType FileRangeWriteType::Update("update"); + const FileRangeWriteType FileRangeWriteType::Clear("clear"); + +}}}}} // namespace Azure::Storage::Files::Shares::Models