8 #include "azure/storage/files/shares/share_file_attributes.hpp"
18 #include <azure/core/datetime.hpp>
19 #include <azure/core/etag.hpp>
20 #include <azure/core/http/http.hpp>
21 #include <azure/core/internal/http/pipeline.hpp>
22 #include <azure/core/internal/json/json.hpp>
23 #include <azure/core/nullable.hpp>
24 #include <azure/core/response.hpp>
25 #include <azure/storage/common/crypt.hpp>
26 #include <azure/storage/common/internal/xml_wrapper.hpp>
27 #include <azure/storage/common/storage_common.hpp>
28 #include <azure/storage/common/storage_exception.hpp>
30 namespace Azure {
namespace Storage {
namespace Files {
namespace Shares {
120 explicit AccessTier(std::string value) : m_value(std::move(value)) {}
121 bool operator==(
const AccessTier& other)
const {
return m_value == other.m_value; }
122 bool operator!=(
const AccessTier& other)
const {
return !(*
this == other); }
123 const std::string& ToString()
const {
return m_value; }
143 bool operator==(
const PermissionCopyMode& other)
const {
return m_value == other.m_value; }
145 const std::string& ToString()
const {
return m_value; }
163 const std::string& ToString()
const {
return m_value; }
326 explicit LeaseDuration(std::string value) : m_value(std::move(value)) {}
327 bool operator==(
const LeaseDuration& other)
const {
return m_value == other.m_value; }
328 bool operator!=(
const LeaseDuration& other)
const {
return !(*
this == other); }
329 const std::string& ToString()
const {
return m_value; }
344 explicit LeaseState(std::string value) : m_value(std::move(value)) {}
345 bool operator==(
const LeaseState& other)
const {
return m_value == other.m_value; }
346 bool operator!=(
const LeaseState& other)
const {
return !(*
this == other); }
347 const std::string& ToString()
const {
return m_value; }
365 explicit LeaseStatus(std::string value) : m_value(std::move(value)) {}
366 bool operator==(
const LeaseStatus& other)
const {
return m_value == other.m_value; }
367 bool operator!=(
const LeaseStatus& other)
const {
return !(*
this == other); }
368 const std::string& ToString()
const {
return m_value; }
623 explicit CopyStatus(std::string value) : m_value(std::move(value)) {}
624 bool operator==(
const CopyStatus& other)
const {
return m_value == other.m_value; }
625 bool operator!=(
const CopyStatus& other)
const {
return !(*
this == other); }
626 const std::string& ToString()
const {
return m_value; }
959 std::vector<SignedIdentifier> SignedIdentifiers;
1428 enum class ListSharesIncludeFlags
1436 inline ListSharesIncludeFlags operator|(ListSharesIncludeFlags lhs, ListSharesIncludeFlags rhs)
1438 using type = std::underlying_type_t<ListSharesIncludeFlags>;
1439 return static_cast<ListSharesIncludeFlags
>(
static_cast<type
>(lhs) |
static_cast<type
>(rhs));
1442 inline ListSharesIncludeFlags& operator|=(
1443 ListSharesIncludeFlags& lhs,
1444 ListSharesIncludeFlags rhs)
1450 inline ListSharesIncludeFlags operator&(ListSharesIncludeFlags lhs, ListSharesIncludeFlags rhs)
1452 using type = std::underlying_type_t<ListSharesIncludeFlags>;
1453 return static_cast<ListSharesIncludeFlags
>(
static_cast<type
>(lhs) &
static_cast<type
>(rhs));
1456 inline ListSharesIncludeFlags& operator&=(
1457 ListSharesIncludeFlags& lhs,
1458 ListSharesIncludeFlags rhs)
1463 inline std::string ListSharesIncludeFlagsToString(
const ListSharesIncludeFlags& val)
1465 ListSharesIncludeFlags value_list[] = {
1466 ListSharesIncludeFlags::Snapshots,
1467 ListSharesIncludeFlags::Metadata,
1468 ListSharesIncludeFlags::Deleted,
1470 const char* string_list[] = {
1476 for (
size_t i = 0; i <
sizeof(value_list) /
sizeof(ListSharesIncludeFlags); ++i)
1478 if ((val & value_list[i]) == value_list[i])
1480 if (!result.empty())
1484 result += string_list[i];
1492 using namespace Models;
1493 constexpr
static const char* DefaultServiceApiVersion =
"2020-02-10";
1494 constexpr
static const char* QueryCopyId =
"copyid";
1495 constexpr
static const char* QueryIncludeFlags =
"include";
1496 constexpr
static const char* QueryContinuationToken =
"marker";
1497 constexpr
static const char* QueryPageSizeHint =
"maxresults";
1498 constexpr
static const char* QueryPrefix =
"prefix";
1499 constexpr
static const char* QueryPrevShareSnapshot =
"prevsharesnapshot";
1500 constexpr
static const char* QueryShareSnapshot =
"sharesnapshot";
1501 constexpr
static const char* QueryTimeout =
"timeout";
1502 constexpr
static const char* QueryRestype =
"restype";
1503 constexpr
static const char* QueryComp =
"comp";
1504 constexpr
static const char* HeaderVersion =
"x-ms-version";
1505 constexpr
static const char* HeaderAccessTier =
"x-ms-access-tier";
1506 constexpr
static const char* HeaderContentLength =
"content-length";
1507 constexpr
static const char* HeaderContentHashMd5 =
"content-md5";
1508 constexpr
static const char* HeaderCopyActionAbortConstant =
"x-ms-copy-action";
1509 constexpr
static const char* HeaderCopySource =
"x-ms-copy-source";
1510 constexpr
static const char* HeaderFilePermissionCopyMode =
"x-ms-file-permission-copy-mode";
1511 constexpr
static const char* HeaderIgnoreReadOnly =
"x-ms-file-copy-ignore-read-only";
1512 constexpr
static const char* HeaderFileAttributes =
"x-ms-file-attributes";
1513 constexpr
static const char* HeaderFileCreatedOn =
"x-ms-file-creation-time";
1514 constexpr
static const char* HeaderFileLastWrittenOn =
"x-ms-file-last-write-time";
1515 constexpr
static const char* HeaderSetArchiveAttribute =
"x-ms-file-copy-set-archive";
1516 constexpr
static const char* HeaderDeletedShareName =
"x-ms-deleted-share-name";
1517 constexpr
static const char* HeaderDeletedShareVersion =
"x-ms-deleted-share-version";
1518 constexpr
static const char* HeaderDeleteSnapshots =
"x-ms-delete-snapshots";
1519 constexpr
static const char* HeaderFileCacheControl =
"x-ms-cache-control";
1520 constexpr
static const char* HeaderFileContentDisposition =
"x-ms-content-disposition";
1521 constexpr
static const char* HeaderFileContentEncoding =
"x-ms-content-encoding";
1522 constexpr
static const char* HeaderFileContentLanguage =
"x-ms-content-language";
1523 constexpr
static const char* HeaderFileContentType =
"x-ms-content-type";
1524 constexpr
static const char* HeaderFilePermission =
"x-ms-file-permission";
1525 constexpr
static const char* HeaderFilePermissionKey =
"x-ms-file-permission-key";
1526 constexpr
static const char* HeaderFileRangeWriteFromUrl =
"x-ms-write";
1527 constexpr
static const char* HeaderFileRangeWriteFromUrlDefault =
"update";
1528 constexpr
static const char* HeaderFileTypeConstant =
"x-ms-type";
1529 constexpr
static const char* HeaderRangeGetContentMd5 =
"x-ms-range-get-content-md5";
1530 constexpr
static const char* HeaderHandleId =
"x-ms-handle-id";
1531 constexpr
static const char* HeaderBreakPeriod =
"x-ms-lease-break-period";
1532 constexpr
static const char* HeaderDuration =
"x-ms-lease-duration";
1533 constexpr
static const char* HeaderLeaseId =
"x-ms-lease-id";
1534 constexpr
static const char* HeaderMetadata =
"x-ms-meta";
1535 constexpr
static const char* HeaderProposedLeaseId =
"x-ms-proposed-lease-id";
1536 constexpr
static const char* HeaderRange =
"x-ms-range";
1537 constexpr
static const char* HeaderRecursive =
"x-ms-recursive";
1538 constexpr
static const char* HeaderQuota =
"x-ms-share-quota";
1539 constexpr
static const char* HeaderSourceContentHashCrc64 =
"x-ms-source-content-crc64";
1540 constexpr
static const char* HeaderSourceIfMatchHashCrc64 =
"x-ms-source-if-match-crc64";
1541 constexpr
static const char* HeaderSourceIfNoneMatchHashCrc64
1542 =
"x-ms-source-if-none-match-crc64";
1543 constexpr
static const char* HeaderSourceRange =
"x-ms-source-range";
1544 constexpr
static const char* HeaderRequestId =
"x-ms-request-id";
1545 constexpr
static const char* HeaderErrorCode =
"x-ms-error-code";
1546 constexpr
static const char* HeaderETag =
"etag";
1547 constexpr
static const char* HeaderLastModified =
"last-modified";
1548 constexpr
static const char* HeaderDate =
"date";
1549 constexpr
static const char* HeaderProvisionedIops =
"x-ms-share-provisioned-iops";
1550 constexpr
static const char* HeaderProvisionedIngressMBps
1551 =
"x-ms-share-provisioned-ingress-mbps";
1552 constexpr
static const char* HeaderProvisionedEgressMBps =
"x-ms-share-provisioned-egress-mbps";
1553 constexpr
static const char* HeaderNextAllowedQuotaDowngradeTime
1554 =
"x-ms-share-next-allowed-quota-downgrade-time";
1555 constexpr
static const char* HeaderLeaseDuration =
"x-ms-lease-duration";
1556 constexpr
static const char* HeaderLeaseState =
"x-ms-lease-state";
1557 constexpr
static const char* HeaderLeaseStatus =
"x-ms-lease-status";
1558 constexpr
static const char* HeaderAccessTierChangedOn =
"x-ms-access-tier-change-time";
1559 constexpr
static const char* HeaderAccessTierTransitionState
1560 =
"x-ms-access-tier-transition-state";
1561 constexpr
static const char* HeaderClientRequestId =
"x-ms-client-request-id";
1562 constexpr
static const char* HeaderAction =
"x-ms-lease-action";
1563 constexpr
static const char* HeaderSnapshot =
"x-ms-snapshot";
1564 constexpr
static const char* HeaderRequestIsServerEncrypted =
"x-ms-request-server-encrypted";
1565 constexpr
static const char* HeaderAttributes =
"x-ms-file-attributes";
1566 constexpr
static const char* HeaderCreatedOn =
"x-ms-file-creation-time";
1567 constexpr
static const char* HeaderLastWrittenOn =
"x-ms-file-last-write-time";
1568 constexpr
static const char* HeaderChangedOn =
"x-ms-file-change-time";
1569 constexpr
static const char* HeaderFileId =
"x-ms-file-id";
1570 constexpr
static const char* HeaderParentFileId =
"x-ms-file-parent-id";
1571 constexpr
static const char* HeaderIsServerEncrypted =
"x-ms-server-encrypted";
1572 constexpr
static const char* HeaderContentType =
"content-type";
1573 constexpr
static const char* HeaderContinuationToken =
"x-ms-marker";
1574 constexpr
static const char* HeaderNumberOfHandlesClosed =
"x-ms-number-of-handles-closed";
1575 constexpr
static const char* HeaderNumberOfHandlesFailedToClose
1576 =
"x-ms-number-of-handles-failed";
1577 constexpr
static const char* HeaderXMsContentLength =
"x-ms-content-length";
1578 constexpr
static const char* HeaderContentRange =
"content-range";
1579 constexpr
static const char* HeaderTransactionalContentHashMd5 =
"content-md5";
1580 constexpr
static const char* HeaderContentEncoding =
"content-encoding";
1581 constexpr
static const char* HeaderCacheControl =
"cache-control";
1582 constexpr
static const char* HeaderContentDisposition =
"content-disposition";
1583 constexpr
static const char* HeaderContentLanguage =
"content-language";
1584 constexpr
static const char* HeaderAcceptRanges =
"accept-ranges";
1585 constexpr
static const char* HeaderCopyCompletedOn =
"x-ms-copy-completion-time";
1586 constexpr
static const char* HeaderCopyStatusDescription =
"x-ms-copy-status-description";
1587 constexpr
static const char* HeaderCopyId =
"x-ms-copy-id";
1588 constexpr
static const char* HeaderCopyProgress =
"x-ms-copy-progress";
1589 constexpr
static const char* HeaderCopyStatus =
"x-ms-copy-status";
1590 constexpr
static const char* HeaderXMsRange =
"x-ms-range";
1591 constexpr
static const char* HeaderFileRangeWrite =
"x-ms-write";
1592 constexpr
static const char* HeaderFileRangeWriteDefault =
"update";
1593 constexpr
static const char* HeaderTransactionalContentHashCrc64 =
"x-ms-content-crc64";
1599 class FileRangeWriteFromUrl final {
1601 FileRangeWriteFromUrl() =
default;
1602 explicit FileRangeWriteFromUrl(std::string value) : m_value(std::move(value)) {}
1603 bool operator==(
const FileRangeWriteFromUrl& other)
const {
return m_value == other.m_value; }
1604 bool operator!=(
const FileRangeWriteFromUrl& other)
const {
return !(*
this == other); }
1605 const std::string& ToString()
const {
return m_value; }
1610 std::string m_value;
1616 struct FilesAndDirectoriesListSinglePage final
1621 std::vector<DirectoryItem> DirectoryItems;
1626 std::vector<FileItem> FileItems;
1632 struct ListFilesAndDirectoriesSinglePageResponse final
1637 std::string ServiceEndpoint;
1642 std::string ShareName;
1647 std::string ShareSnapshot;
1652 std::string DirectoryPath;
1662 int32_t PageSizeHint = int32_t();
1667 FilesAndDirectoriesListSinglePage SinglePage;
1672 Azure::Nullable<std::string> ContinuationToken;
1678 struct ListHandlesResponse final
1683 std::vector<HandleItem> HandleList;
1688 Azure::Nullable<std::string> ContinuationToken;
1694 struct ListSharesResponse final
1699 std::string ServiceEndpoint;
1709 int32_t PageSizeHint = int32_t();
1714 std::vector<ShareItem> Items;
1719 Azure::Nullable<std::string> ContinuationToken;
1725 struct FileRange final
1730 int64_t Start = int64_t();
1735 int64_t End = int64_t();
1741 struct ClearRange final
1746 int64_t Start = int64_t();
1751 int64_t End = int64_t();
1757 struct RangeList final
1762 std::vector<Core::Http::HttpRange> Ranges;
1767 std::vector<Core::Http::HttpRange> ClearRanges;
1773 struct ShareStats final
1779 int64_t ShareUsageInBytes = int64_t();
1785 struct SharePermission final
1790 std::string FilePermission;
1796 class LeaseAction final {
1798 LeaseAction() =
default;
1799 explicit LeaseAction(std::string value) : m_value(std::move(value)) {}
1800 bool operator==(
const LeaseAction& other)
const {
return m_value == other.m_value; }
1801 bool operator!=(
const LeaseAction& other)
const {
return !(*
this == other); }
1802 const std::string& ToString()
const {
return m_value; }
1811 std::string m_value;
1821 class FileRangeWrite final {
1823 FileRangeWrite() =
default;
1824 explicit FileRangeWrite(std::string value) : m_value(std::move(value)) {}
1825 bool operator==(
const FileRangeWrite& other)
const {
return m_value == other.m_value; }
1826 bool operator!=(
const FileRangeWrite& other)
const {
return !(*
this == other); }
1827 const std::string& ToString()
const {
return m_value; }
1833 std::string m_value;
1836 struct ServiceGetPropertiesResult final
1841 Metrics HourMetrics;
1846 Metrics MinuteMetrics;
1851 std::vector<CorsRule> Cors;
1856 Azure::Nullable<ProtocolSettings> Protocol;
1859 struct ServiceListSharesSinglePageResult final
1864 std::string ServiceEndpoint;
1874 int32_t PageSizeHint = int32_t();
1879 std::vector<ShareItem> Items;
1884 Azure::Nullable<std::string> ContinuationToken;
1887 struct ShareGetPermissionResult final
1892 std::string FilePermission;
1895 struct ShareRestoreResult final
1908 DateTime LastModified;
1911 struct DirectoryListFilesAndDirectoriesSinglePageResult final
1916 std::string ServiceEndpoint;
1921 std::string ShareName;
1926 std::string ShareSnapshot;
1931 std::string DirectoryPath;
1941 int32_t PageSizeHint = int32_t();
1946 FilesAndDirectoriesListSinglePage SinglePage;
1951 Azure::Nullable<std::string> ContinuationToken;
1956 FileHttpHeaders HttpHeaders;
1959 struct DirectoryListHandlesResult final
1964 std::vector<HandleItem> HandleList;
1969 Azure::Nullable<std::string> ContinuationToken;
1974 FileHttpHeaders HttpHeaders;
1977 struct DirectoryForceCloseHandlesResult final
1984 Azure::Nullable<std::string> ContinuationToken;
1989 int32_t NumberOfHandlesClosed = int32_t();
1994 int32_t NumberOfHandlesFailedToClose = int32_t();
1997 struct FileDownloadResult final
1999 std::unique_ptr<Azure::Core::IO::BodyStream> BodyStream;
2005 DateTime LastModified;
2010 Storage::Metadata Metadata;
2015 FileHttpHeaders HttpHeaders;
2020 Azure::Core::Http::HttpRange ContentRange;
2025 int64_t FileSize = int64_t();
2040 Azure::Nullable<Storage::ContentHash> TransactionalContentHash;
2045 std::string AcceptRanges;
2052 Azure::Nullable<DateTime> CopyCompletedOn;
2058 Azure::Nullable<std::string> CopyStatusDescription;
2064 Azure::Nullable<std::string> CopyId;
2071 Azure::Nullable<std::string> CopyProgress;
2077 Azure::Nullable<std::string> CopySource;
2082 Azure::Nullable<Models::CopyStatus> CopyStatus;
2090 bool IsServerEncrypted = bool();
2095 FileSmbProperties SmbProperties;
2101 Azure::Nullable<Models::LeaseDuration> LeaseDuration;
2106 Azure::Nullable<Models::LeaseState> LeaseState;
2111 Azure::Nullable<Models::LeaseStatus> LeaseStatus;
2114 struct FileAcquireLeaseResult final
2128 DateTime LastModified;
2133 std::string LeaseId;
2136 struct FileReleaseLeaseResult final
2150 DateTime LastModified;
2153 struct FileChangeLeaseResult final
2167 DateTime LastModified;
2172 std::string LeaseId;
2175 struct FileBreakLeaseResult final
2189 DateTime LastModified;
2194 Azure::Nullable<std::string> LeaseId;
2197 struct FileStartCopyResult final
2209 DateTime LastModified;
2221 Models::CopyStatus CopyStatus;
2224 struct FileListHandlesResult final
2229 std::vector<HandleItem> HandleList;
2234 Azure::Nullable<std::string> ContinuationToken;
2239 FileHttpHeaders HttpHeaders;
2242 struct FileForceCloseHandlesResult final
2249 Azure::Nullable<std::string> ContinuationToken;
2254 int32_t NumberOfHandlesClosed = int32_t();
2259 int32_t NumberOfHandlesFailedToClose = int32_t();
2262 class ShareRestClient final {
2264 static Azure::Core::Http::HttpRange HttpRangeFromXml(_internal::XmlReader& reader)
2267 bool is_start =
false;
2268 bool is_end =
false;
2273 auto node = reader.Read();
2274 if (node.Type == _internal::XmlNodeType::End)
2278 else if (node.Type == _internal::XmlNodeType::StartTag && strcmp(node.Name,
"Start") == 0)
2283 else if (node.Type == _internal::XmlNodeType::StartTag && strcmp(node.Name,
"End") == 0)
2288 else if (node.Type == _internal::XmlNodeType::EndTag)
2297 if (depth == 1 && node.Type == _internal::XmlNodeType::Text)
2301 start = std::stoll(node.Value);
2305 end = std::stoll(node.Value);
2309 Azure::Core::Http::HttpRange ret;
2311 ret.Length = end - start + 1;
2316 class Service final {
2318 struct SetPropertiesOptions final
2320 ShareServiceProperties ServiceProperties;
2321 Azure::Nullable<int32_t> Timeout;
2322 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
2325 static Azure::Response<Models::SetServicePropertiesResult> SetProperties(
2326 const Azure::Core::Url& url,
2327 Azure::Core::Http::_internal::HttpPipeline& pipeline,
2328 Azure::Core::Context context,
2329 const SetPropertiesOptions& setPropertiesOptions)
2332 std::string xml_body;
2334 _internal::XmlWriter writer;
2335 ShareServicePropertiesToXml(writer, setPropertiesOptions.ServiceProperties);
2336 writer.Write(_internal::XmlNode{_internal::XmlNodeType::End});
2337 xml_body = writer.GetDocument();
2339 auto body = Azure::Core::IO::MemoryBodyStream(
2340 reinterpret_cast<const uint8_t*
>(xml_body.data()), xml_body.length());
2341 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &body);
2342 request.SetHeader(
"Content-Length", std::to_string(body.Length()));
2343 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"service");
2344 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"properties");
2345 if (setPropertiesOptions.Timeout.HasValue())
2347 request.GetUrl().AppendQueryParameter(
2348 _detail::QueryTimeout,
2349 _internal::UrlEncodeQueryParameter(
2350 std::to_string(setPropertiesOptions.Timeout.Value())));
2352 request.SetHeader(_detail::HeaderVersion, setPropertiesOptions.ApiVersionParameter);
2353 return SetPropertiesParseResult(context, pipeline.Send(request, context));
2356 struct GetPropertiesOptions final
2358 Azure::Nullable<int32_t> Timeout;
2359 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
2362 static Azure::Response<ServiceGetPropertiesResult> GetProperties(
2363 const Azure::Core::Url& url,
2364 Azure::Core::Http::_internal::HttpPipeline& pipeline,
2365 Azure::Core::Context context,
2366 const GetPropertiesOptions& getPropertiesOptions)
2368 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
2369 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"service");
2370 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"properties");
2371 if (getPropertiesOptions.Timeout.HasValue())
2373 request.GetUrl().AppendQueryParameter(
2374 _detail::QueryTimeout,
2375 _internal::UrlEncodeQueryParameter(
2376 std::to_string(getPropertiesOptions.Timeout.Value())));
2378 request.SetHeader(_detail::HeaderVersion, getPropertiesOptions.ApiVersionParameter);
2379 return GetPropertiesParseResult(context, pipeline.Send(request, context));
2382 struct ListSharesSinglePageOptions final
2384 Azure::Nullable<std::string> Prefix;
2385 Azure::Nullable<std::string> ContinuationToken;
2386 Azure::Nullable<int32_t> MaxResults;
2387 Azure::Nullable<ListSharesIncludeFlags> IncludeFlags;
2388 Azure::Nullable<int32_t> Timeout;
2389 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
2392 static Azure::Response<ServiceListSharesSinglePageResult> ListSharesSinglePage(
2393 const Azure::Core::Url& url,
2394 Azure::Core::Http::_internal::HttpPipeline& pipeline,
2395 Azure::Core::Context context,
2396 const ListSharesSinglePageOptions& listSharesSinglePageOptions)
2398 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
2399 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"list");
2400 if (listSharesSinglePageOptions.Prefix.HasValue())
2402 request.GetUrl().AppendQueryParameter(
2403 _detail::QueryPrefix,
2404 _internal::UrlEncodeQueryParameter(listSharesSinglePageOptions.Prefix.Value()));
2406 if (listSharesSinglePageOptions.ContinuationToken.HasValue())
2408 request.GetUrl().AppendQueryParameter(
2409 _detail::QueryContinuationToken,
2410 _internal::UrlEncodeQueryParameter(
2411 listSharesSinglePageOptions.ContinuationToken.Value()));
2413 if (listSharesSinglePageOptions.MaxResults.HasValue())
2415 request.GetUrl().AppendQueryParameter(
2416 _detail::QueryPageSizeHint,
2417 _internal::UrlEncodeQueryParameter(
2418 std::to_string(listSharesSinglePageOptions.MaxResults.Value())));
2420 if (listSharesSinglePageOptions.IncludeFlags.HasValue())
2422 request.GetUrl().AppendQueryParameter(
2423 _detail::QueryIncludeFlags,
2424 _internal::UrlEncodeQueryParameter(ListSharesIncludeFlagsToString(
2425 listSharesSinglePageOptions.IncludeFlags.Value())));
2427 if (listSharesSinglePageOptions.Timeout.HasValue())
2429 request.GetUrl().AppendQueryParameter(
2430 _detail::QueryTimeout,
2431 _internal::UrlEncodeQueryParameter(
2432 std::to_string(listSharesSinglePageOptions.Timeout.Value())));
2435 _detail::HeaderVersion, listSharesSinglePageOptions.ApiVersionParameter);
2436 return ListSharesSinglePageParseResult(context, pipeline.Send(request, context));
2440 static Azure::Response<Models::SetServicePropertiesResult> SetPropertiesParseResult(
2441 Azure::Core::Context context,
2442 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
2444 auto& response = *responsePtr;
2445 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)
2448 Models::SetServicePropertiesResult result;
2449 return Azure::Response<Models::SetServicePropertiesResult>(
2450 std::move(result), std::move(responsePtr));
2455 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
2459 static void RetentionPolicyToXml(
2460 _internal::XmlWriter& writer,
2461 const RetentionPolicy&
object)
2463 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Enabled"});
2464 writer.Write(_internal::XmlNode{
2465 _internal::XmlNodeType::Text,
nullptr,
object.Enabled ?
"true" :
"false"});
2466 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2467 if (
object.Days.HasValue())
2469 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Days"});
2470 writer.Write(_internal::XmlNode{
2471 _internal::XmlNodeType::Text,
nullptr, std::to_string(
object.Days.Value()).data()});
2472 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2476 static void MetricsToXml(_internal::XmlWriter& writer,
const Metrics&
object)
2478 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Version"});
2480 _internal::XmlNode{_internal::XmlNodeType::Text,
nullptr,
object.Version.data()});
2481 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2482 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Enabled"});
2483 writer.Write(_internal::XmlNode{
2484 _internal::XmlNodeType::Text,
nullptr,
object.Enabled ?
"true" :
"false"});
2485 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2486 if (
object.IncludeApis.HasValue())
2488 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"IncludeAPIs"});
2489 writer.Write(_internal::XmlNode{
2490 _internal::XmlNodeType::Text,
2492 object.IncludeApis.Value() ?
"true" :
"false"});
2493 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2495 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"RetentionPolicy"});
2496 RetentionPolicyToXml(writer,
object.RetentionPolicy);
2497 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2500 static void CorsRuleToXml(_internal::XmlWriter& writer,
const CorsRule&
object)
2502 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"CorsRule"});
2503 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"AllowedOrigins"});
2504 writer.Write(_internal::XmlNode{
2505 _internal::XmlNodeType::Text,
nullptr,
object.AllowedOrigins.data()});
2506 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2507 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"AllowedMethods"});
2508 writer.Write(_internal::XmlNode{
2509 _internal::XmlNodeType::Text,
nullptr,
object.AllowedMethods.data()});
2510 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2511 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"AllowedHeaders"});
2512 writer.Write(_internal::XmlNode{
2513 _internal::XmlNodeType::Text,
nullptr,
object.AllowedHeaders.data()});
2514 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2515 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"ExposedHeaders"});
2516 writer.Write(_internal::XmlNode{
2517 _internal::XmlNodeType::Text,
nullptr,
object.ExposedHeaders.data()});
2518 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2519 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"MaxAgeInSeconds"});
2520 writer.Write(_internal::XmlNode{
2521 _internal::XmlNodeType::Text,
2523 std::to_string(
object.MaxAgeInSeconds).data()});
2524 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2525 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2528 static void SmbMultichannelToXml(
2529 _internal::XmlWriter& writer,
2530 const SmbMultichannel&
object)
2532 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Multichannel"});
2533 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Enabled"});
2534 writer.Write(_internal::XmlNode{
2535 _internal::XmlNodeType::Text,
nullptr,
object.Enabled ?
"true" :
"false"});
2536 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2537 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2540 static void SmbSettingsToXml(_internal::XmlWriter& writer,
const SmbSettings&
object)
2542 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"SMB"});
2543 SmbMultichannelToXml(writer,
object.Multichannel);
2544 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2547 static void ProtocolSettingsToXml(
2548 _internal::XmlWriter& writer,
2549 const ProtocolSettings&
object)
2551 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"ProtocolSettings"});
2552 SmbSettingsToXml(writer,
object.Settings);
2553 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2556 static void ShareServicePropertiesToXml(
2557 _internal::XmlWriter& writer,
2558 const ShareServiceProperties&
object)
2561 _internal::XmlNode{_internal::XmlNodeType::StartTag,
"StorageServiceProperties"});
2562 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"HourMetrics"});
2563 MetricsToXml(writer,
object.HourMetrics);
2564 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2565 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"MinuteMetrics"});
2566 MetricsToXml(writer,
object.MinuteMetrics);
2567 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2568 if (
object.Cors.size() > 0)
2570 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Cors"});
2571 for (
const auto& item :
object.Cors)
2573 CorsRuleToXml(writer, item);
2575 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2577 if (
object.Protocol.HasValue())
2579 ProtocolSettingsToXml(writer,
object.Protocol.Value());
2581 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
2583 static Azure::Response<ServiceGetPropertiesResult> GetPropertiesParseResult(
2584 Azure::Core::Context context,
2585 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
2587 auto& response = *responsePtr;
2588 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
2591 const auto& bodyBuffer = response.GetBody();
2592 auto reader = _internal::XmlReader(
2593 reinterpret_cast<const char*
>(bodyBuffer.data()), bodyBuffer.size());
2594 ServiceGetPropertiesResult result = bodyBuffer.empty()
2595 ? ServiceGetPropertiesResult()
2596 : ServiceGetPropertiesResultFromShareServiceProperties(
2597 ShareServicePropertiesFromXml(reader));
2598 return Azure::Response<ServiceGetPropertiesResult>(
2599 std::move(result), std::move(responsePtr));
2604 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
2608 static RetentionPolicy RetentionPolicyFromXml(_internal::XmlReader& reader)
2610 auto result = RetentionPolicy();
2611 enum class XmlTagName
2617 std::vector<XmlTagName> path;
2621 auto node = reader.Read();
2622 if (node.Type == _internal::XmlNodeType::End)
2626 else if (node.Type == _internal::XmlNodeType::EndTag)
2628 if (path.size() > 0)
2637 else if (node.Type == _internal::XmlNodeType::StartTag)
2640 if (std::strcmp(node.Name,
"Days") == 0)
2642 path.emplace_back(XmlTagName::Days);
2644 else if (std::strcmp(node.Name,
"Enabled") == 0)
2646 path.emplace_back(XmlTagName::Enabled);
2650 path.emplace_back(XmlTagName::Unknown);
2653 else if (node.Type == _internal::XmlNodeType::Text)
2655 if (path.size() == 1 && path[0] == XmlTagName::Days)
2657 result.Days = std::stoi(node.Value);
2659 else if (path.size() == 1 && path[0] == XmlTagName::Enabled)
2661 result.Enabled = (std::strcmp(node.Value,
"true") == 0);
2668 static Metrics MetricsFromXml(_internal::XmlReader& reader)
2670 auto result = Metrics();
2671 enum class XmlTagName
2679 std::vector<XmlTagName> path;
2683 auto node = reader.Read();
2684 if (node.Type == _internal::XmlNodeType::End)
2688 else if (node.Type == _internal::XmlNodeType::EndTag)
2690 if (path.size() > 0)
2699 else if (node.Type == _internal::XmlNodeType::StartTag)
2702 if (std::strcmp(node.Name,
"Enabled") == 0)
2704 path.emplace_back(XmlTagName::Enabled);
2706 else if (std::strcmp(node.Name,
"IncludeAPIs") == 0)
2708 path.emplace_back(XmlTagName::IncludeAPIs);
2710 else if (std::strcmp(node.Name,
"RetentionPolicy") == 0)
2712 path.emplace_back(XmlTagName::RetentionPolicy);
2714 else if (std::strcmp(node.Name,
"Version") == 0)
2716 path.emplace_back(XmlTagName::Version);
2720 path.emplace_back(XmlTagName::Unknown);
2723 if (path.size() == 1 && path[0] == XmlTagName::RetentionPolicy)
2725 result.RetentionPolicy = RetentionPolicyFromXml(reader);
2729 else if (node.Type == _internal::XmlNodeType::Text)
2731 if (path.size() == 1 && path[0] == XmlTagName::Enabled)
2733 result.Enabled = (std::strcmp(node.Value,
"true") == 0);
2735 else if (path.size() == 1 && path[0] == XmlTagName::IncludeAPIs)
2737 result.IncludeApis = (std::strcmp(node.Value,
"true") == 0);
2739 else if (path.size() == 1 && path[0] == XmlTagName::Version)
2741 result.Version = node.Value;
2748 static CorsRule CorsRuleFromXml(_internal::XmlReader& reader)
2750 auto result = CorsRule();
2751 enum class XmlTagName
2760 std::vector<XmlTagName> path;
2764 auto node = reader.Read();
2765 if (node.Type == _internal::XmlNodeType::End)
2769 else if (node.Type == _internal::XmlNodeType::EndTag)
2771 if (path.size() > 0)
2780 else if (node.Type == _internal::XmlNodeType::StartTag)
2783 if (std::strcmp(node.Name,
"AllowedHeaders") == 0)
2785 path.emplace_back(XmlTagName::AllowedHeaders);
2787 else if (std::strcmp(node.Name,
"AllowedMethods") == 0)
2789 path.emplace_back(XmlTagName::AllowedMethods);
2791 else if (std::strcmp(node.Name,
"AllowedOrigins") == 0)
2793 path.emplace_back(XmlTagName::AllowedOrigins);
2795 else if (std::strcmp(node.Name,
"ExposedHeaders") == 0)
2797 path.emplace_back(XmlTagName::ExposedHeaders);
2799 else if (std::strcmp(node.Name,
"MaxAgeInSeconds") == 0)
2801 path.emplace_back(XmlTagName::MaxAgeInSeconds);
2805 path.emplace_back(XmlTagName::Unknown);
2808 else if (node.Type == _internal::XmlNodeType::Text)
2810 if (path.size() == 1 && path[0] == XmlTagName::AllowedHeaders)
2812 result.AllowedHeaders = node.Value;
2814 else if (path.size() == 1 && path[0] == XmlTagName::AllowedMethods)
2816 result.AllowedMethods = node.Value;
2818 else if (path.size() == 1 && path[0] == XmlTagName::AllowedOrigins)
2820 result.AllowedOrigins = node.Value;
2822 else if (path.size() == 1 && path[0] == XmlTagName::ExposedHeaders)
2824 result.ExposedHeaders = node.Value;
2826 else if (path.size() == 1 && path[0] == XmlTagName::MaxAgeInSeconds)
2828 result.MaxAgeInSeconds = std::stoi(node.Value);
2835 static SmbMultichannel SmbMultichannelFromXml(_internal::XmlReader& reader)
2837 auto result = SmbMultichannel();
2838 enum class XmlTagName
2843 std::vector<XmlTagName> path;
2847 auto node = reader.Read();
2848 if (node.Type == _internal::XmlNodeType::End)
2852 else if (node.Type == _internal::XmlNodeType::EndTag)
2854 if (path.size() > 0)
2863 else if (node.Type == _internal::XmlNodeType::StartTag)
2866 if (std::strcmp(node.Name,
"Enabled") == 0)
2868 path.emplace_back(XmlTagName::Enabled);
2872 path.emplace_back(XmlTagName::Unknown);
2875 else if (node.Type == _internal::XmlNodeType::Text)
2877 if (path.size() == 1 && path[0] == XmlTagName::Enabled)
2879 result.Enabled = (std::strcmp(node.Value,
"true") == 0);
2886 static SmbSettings SmbSettingsFromXml(_internal::XmlReader& reader)
2888 auto result = SmbSettings();
2889 enum class XmlTagName
2894 std::vector<XmlTagName> path;
2898 auto node = reader.Read();
2899 if (node.Type == _internal::XmlNodeType::End)
2903 else if (node.Type == _internal::XmlNodeType::EndTag)
2905 if (path.size() > 0)
2914 else if (node.Type == _internal::XmlNodeType::StartTag)
2917 if (std::strcmp(node.Name,
"Multichannel") == 0)
2919 path.emplace_back(XmlTagName::Multichannel);
2923 path.emplace_back(XmlTagName::Unknown);
2926 if (path.size() == 1 && path[0] == XmlTagName::Multichannel)
2928 result.Multichannel = SmbMultichannelFromXml(reader);
2932 else if (node.Type == _internal::XmlNodeType::Text)
2939 static ProtocolSettings ProtocolSettingsFromXml(_internal::XmlReader& reader)
2941 auto result = ProtocolSettings();
2942 enum class XmlTagName
2947 std::vector<XmlTagName> path;
2951 auto node = reader.Read();
2952 if (node.Type == _internal::XmlNodeType::End)
2956 else if (node.Type == _internal::XmlNodeType::EndTag)
2958 if (path.size() > 0)
2967 else if (node.Type == _internal::XmlNodeType::StartTag)
2970 if (std::strcmp(node.Name,
"SMB") == 0)
2972 path.emplace_back(XmlTagName::SMB);
2976 path.emplace_back(XmlTagName::Unknown);
2979 if (path.size() == 1 && path[0] == XmlTagName::SMB)
2981 result.Settings = SmbSettingsFromXml(reader);
2985 else if (node.Type == _internal::XmlNodeType::Text)
2992 static ShareServiceProperties ShareServicePropertiesFromXml(_internal::XmlReader& reader)
2994 auto result = ShareServiceProperties();
2995 enum class XmlTagName
3002 StorageServiceProperties,
3005 std::vector<XmlTagName> path;
3009 auto node = reader.Read();
3010 if (node.Type == _internal::XmlNodeType::End)
3014 else if (node.Type == _internal::XmlNodeType::EndTag)
3016 if (path.size() > 0)
3025 else if (node.Type == _internal::XmlNodeType::StartTag)
3028 if (std::strcmp(node.Name,
"Cors") == 0)
3030 path.emplace_back(XmlTagName::Cors);
3032 else if (std::strcmp(node.Name,
"CorsRule") == 0)
3034 path.emplace_back(XmlTagName::CorsRule);
3036 else if (std::strcmp(node.Name,
"HourMetrics") == 0)
3038 path.emplace_back(XmlTagName::HourMetrics);
3040 else if (std::strcmp(node.Name,
"MinuteMetrics") == 0)
3042 path.emplace_back(XmlTagName::MinuteMetrics);
3044 else if (std::strcmp(node.Name,
"ProtocolSettings") == 0)
3046 path.emplace_back(XmlTagName::ProtocolSettings);
3048 else if (std::strcmp(node.Name,
"StorageServiceProperties") == 0)
3050 path.emplace_back(XmlTagName::StorageServiceProperties);
3054 path.emplace_back(XmlTagName::Unknown);
3057 if (path.size() == 2 && path[0] == XmlTagName::StorageServiceProperties
3058 && path[1] == XmlTagName::HourMetrics)
3060 result.HourMetrics = MetricsFromXml(reader);
3064 path.size() == 2 && path[0] == XmlTagName::StorageServiceProperties
3065 && path[1] == XmlTagName::MinuteMetrics)
3067 result.MinuteMetrics = MetricsFromXml(reader);
3071 path.size() == 2 && path[0] == XmlTagName::StorageServiceProperties
3072 && path[1] == XmlTagName::ProtocolSettings)
3074 result.Protocol = ProtocolSettingsFromXml(reader);
3078 path.size() == 3 && path[0] == XmlTagName::StorageServiceProperties
3079 && path[1] == XmlTagName::Cors && path[2] == XmlTagName::CorsRule)
3081 result.Cors.emplace_back(CorsRuleFromXml(reader));
3085 else if (node.Type == _internal::XmlNodeType::Text)
3092 static ServiceGetPropertiesResult ServiceGetPropertiesResultFromShareServiceProperties(
3093 ShareServiceProperties
object)
3095 ServiceGetPropertiesResult result;
3096 result.HourMetrics = std::move(
object.HourMetrics);
3097 result.MinuteMetrics = std::move(
object.MinuteMetrics);
3098 result.Cors = std::move(
object.Cors);
3099 result.Protocol = std::move(
object.Protocol);
3103 static Azure::Response<ServiceListSharesSinglePageResult> ListSharesSinglePageParseResult(
3104 Azure::Core::Context context,
3105 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
3107 auto& response = *responsePtr;
3108 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
3111 const auto& bodyBuffer = response.GetBody();
3112 auto reader = _internal::XmlReader(
3113 reinterpret_cast<const char*
>(bodyBuffer.data()), bodyBuffer.size());
3114 ServiceListSharesSinglePageResult result = bodyBuffer.empty()
3115 ? ServiceListSharesSinglePageResult()
3116 : ServiceListSharesSinglePageResultFromListSharesResponse(
3117 ListSharesResponseFromXml(reader));
3118 return Azure::Response<ServiceListSharesSinglePageResult>(
3119 std::move(result), std::move(responsePtr));
3124 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
3128 static LeaseStatus LeaseStatusFromXml(_internal::XmlReader& reader)
3131 enum class XmlTagName
3136 std::vector<XmlTagName> path;
3140 auto node = reader.Read();
3141 if (node.Type == _internal::XmlNodeType::End)
3145 else if (node.Type == _internal::XmlNodeType::EndTag)
3147 if (path.size() > 0)
3156 else if (node.Type == _internal::XmlNodeType::StartTag)
3159 if (std::strcmp(node.Name,
"LeaseStatus") == 0)
3161 path.emplace_back(XmlTagName::LeaseStatus);
3165 path.emplace_back(XmlTagName::Unknown);
3168 else if (node.Type == _internal::XmlNodeType::Text)
3170 if (path.size() == 1 && path[0] == XmlTagName::LeaseStatus)
3172 result = LeaseStatus(node.Value);
3179 static LeaseState LeaseStateFromXml(_internal::XmlReader& reader)
3182 enum class XmlTagName
3187 std::vector<XmlTagName> path;
3191 auto node = reader.Read();
3192 if (node.Type == _internal::XmlNodeType::End)
3196 else if (node.Type == _internal::XmlNodeType::EndTag)
3198 if (path.size() > 0)
3207 else if (node.Type == _internal::XmlNodeType::StartTag)
3210 if (std::strcmp(node.Name,
"LeaseState") == 0)
3212 path.emplace_back(XmlTagName::LeaseState);
3216 path.emplace_back(XmlTagName::Unknown);
3219 else if (node.Type == _internal::XmlNodeType::Text)
3221 if (path.size() == 1 && path[0] == XmlTagName::LeaseState)
3223 result = LeaseState(node.Value);
3230 static LeaseDuration LeaseDurationFromXml(_internal::XmlReader& reader)
3232 LeaseDuration result;
3233 enum class XmlTagName
3238 std::vector<XmlTagName> path;
3242 auto node = reader.Read();
3243 if (node.Type == _internal::XmlNodeType::End)
3247 else if (node.Type == _internal::XmlNodeType::EndTag)
3249 if (path.size() > 0)
3258 else if (node.Type == _internal::XmlNodeType::StartTag)
3261 if (std::strcmp(node.Name,
"LeaseDuration") == 0)
3263 path.emplace_back(XmlTagName::LeaseDuration);
3267 path.emplace_back(XmlTagName::Unknown);
3270 else if (node.Type == _internal::XmlNodeType::Text)
3272 if (path.size() == 1 && path[0] == XmlTagName::LeaseDuration)
3274 result = LeaseDuration(node.Value);
3281 static ShareItemDetails ShareItemDetailsFromXml(_internal::XmlReader& reader)
3283 auto result = ShareItemDetails();
3284 enum class XmlTagName
3287 AccessTierChangeTime,
3288 AccessTierTransitionState,
3295 NextAllowedQuotaDowngradeTime,
3296 ProvisionedEgressMBps,
3297 ProvisionedIngressMBps,
3300 RemainingRetentionDays,
3303 std::vector<XmlTagName> path;
3307 auto node = reader.Read();
3308 if (node.Type == _internal::XmlNodeType::End)
3312 else if (node.Type == _internal::XmlNodeType::EndTag)
3314 if (path.size() > 0)
3323 else if (node.Type == _internal::XmlNodeType::StartTag)
3326 if (std::strcmp(node.Name,
"AccessTier") == 0)
3328 path.emplace_back(XmlTagName::AccessTier);
3330 else if (std::strcmp(node.Name,
"AccessTierChangeTime") == 0)
3332 path.emplace_back(XmlTagName::AccessTierChangeTime);
3334 else if (std::strcmp(node.Name,
"AccessTierTransitionState") == 0)
3336 path.emplace_back(XmlTagName::AccessTierTransitionState);
3338 else if (std::strcmp(node.Name,
"DeletedTime") == 0)
3340 path.emplace_back(XmlTagName::DeletedTime);
3342 else if (std::strcmp(node.Name,
"Etag") == 0)
3344 path.emplace_back(XmlTagName::Etag);
3346 else if (std::strcmp(node.Name,
"Last-Modified") == 0)
3348 path.emplace_back(XmlTagName::LastModified);
3350 else if (std::strcmp(node.Name,
"LeaseDuration") == 0)
3352 path.emplace_back(XmlTagName::LeaseDuration);
3354 else if (std::strcmp(node.Name,
"LeaseState") == 0)
3356 path.emplace_back(XmlTagName::LeaseState);
3358 else if (std::strcmp(node.Name,
"LeaseStatus") == 0)
3360 path.emplace_back(XmlTagName::LeaseStatus);
3362 else if (std::strcmp(node.Name,
"NextAllowedQuotaDowngradeTime") == 0)
3364 path.emplace_back(XmlTagName::NextAllowedQuotaDowngradeTime);
3366 else if (std::strcmp(node.Name,
"ProvisionedEgressMBps") == 0)
3368 path.emplace_back(XmlTagName::ProvisionedEgressMBps);
3370 else if (std::strcmp(node.Name,
"ProvisionedIngressMBps") == 0)
3372 path.emplace_back(XmlTagName::ProvisionedIngressMBps);
3374 else if (std::strcmp(node.Name,
"ProvisionedIops") == 0)
3376 path.emplace_back(XmlTagName::ProvisionedIops);
3378 else if (std::strcmp(node.Name,
"Quota") == 0)
3380 path.emplace_back(XmlTagName::Quota);
3382 else if (std::strcmp(node.Name,
"RemainingRetentionDays") == 0)
3384 path.emplace_back(XmlTagName::RemainingRetentionDays);
3388 path.emplace_back(XmlTagName::Unknown);
3391 if (path.size() == 1 && path[0] == XmlTagName::LeaseStatus)
3393 result.LeaseStatus = LeaseStatusFromXml(reader);
3396 else if (path.size() == 1 && path[0] == XmlTagName::LeaseState)
3398 result.LeaseState = LeaseStateFromXml(reader);
3401 else if (path.size() == 1 && path[0] == XmlTagName::LeaseDuration)
3403 result.LeaseDuration = LeaseDurationFromXml(reader);
3407 else if (node.Type == _internal::XmlNodeType::Text)
3409 if (path.size() == 1 && path[0] == XmlTagName::AccessTier)
3411 result.AccessTier = AccessTier(node.Value);
3413 else if (path.size() == 1 && path[0] == XmlTagName::AccessTierChangeTime)
3415 result.AccessTierChangedOn
3416 = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc1123);
3418 else if (path.size() == 1 && path[0] == XmlTagName::AccessTierTransitionState)
3420 result.AccessTierTransitionState = node.Value;
3422 else if (path.size() == 1 && path[0] == XmlTagName::DeletedTime)
3424 result.DeletedOn = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc1123);
3426 else if (path.size() == 1 && path[0] == XmlTagName::Etag)
3428 result.Etag = Azure::ETag(node.Value);
3430 else if (path.size() == 1 && path[0] == XmlTagName::LastModified)
3432 result.LastModified = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc1123);
3434 else if (path.size() == 1 && path[0] == XmlTagName::NextAllowedQuotaDowngradeTime)
3436 result.NextAllowedQuotaDowngradeTime
3437 = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc1123);
3439 else if (path.size() == 1 && path[0] == XmlTagName::ProvisionedEgressMBps)
3441 result.ProvisionedEgressMBps = std::stoi(node.Value);
3443 else if (path.size() == 1 && path[0] == XmlTagName::ProvisionedIngressMBps)
3445 result.ProvisionedIngressMBps = std::stoi(node.Value);
3447 else if (path.size() == 1 && path[0] == XmlTagName::ProvisionedIops)
3449 result.ProvisionedIops = std::stoi(node.Value);
3451 else if (path.size() == 1 && path[0] == XmlTagName::Quota)
3453 result.Quota = std::stoll(node.Value);
3455 else if (path.size() == 1 && path[0] == XmlTagName::RemainingRetentionDays)
3457 result.RemainingRetentionDays = std::stoi(node.Value);
3464 static Metadata MetadataFromXml(_internal::XmlReader& reader)
3471 auto node = reader.Read();
3472 if (node.Type == _internal::XmlNodeType::End)
3476 else if (node.Type == _internal::XmlNodeType::StartTag)
3483 else if (node.Type == _internal::XmlNodeType::EndTag)
3490 else if (depth == 1 && node.Type == _internal::XmlNodeType::Text)
3492 result.emplace(std::move(key), std::string(node.Value));
3498 static ShareItem ShareItemFromXml(_internal::XmlReader& reader)
3500 auto result = ShareItem();
3501 enum class XmlTagName
3511 std::vector<XmlTagName> path;
3515 auto node = reader.Read();
3516 if (node.Type == _internal::XmlNodeType::End)
3520 else if (node.Type == _internal::XmlNodeType::EndTag)
3522 if (path.size() > 0)
3531 else if (node.Type == _internal::XmlNodeType::StartTag)
3534 if (std::strcmp(node.Name,
"Deleted") == 0)
3536 path.emplace_back(XmlTagName::Deleted);
3538 else if (std::strcmp(node.Name,
"Metadata") == 0)
3540 path.emplace_back(XmlTagName::Metadata);
3542 else if (std::strcmp(node.Name,
"Name") == 0)
3544 path.emplace_back(XmlTagName::Name);
3546 else if (std::strcmp(node.Name,
"Properties") == 0)
3548 path.emplace_back(XmlTagName::Properties);
3550 else if (std::strcmp(node.Name,
"Snapshot") == 0)
3552 path.emplace_back(XmlTagName::Snapshot);
3554 else if (std::strcmp(node.Name,
"Version") == 0)
3556 path.emplace_back(XmlTagName::Version);
3560 path.emplace_back(XmlTagName::Unknown);
3563 if (path.size() == 1 && path[0] == XmlTagName::Properties)
3565 result.Details = ShareItemDetailsFromXml(reader);
3568 else if (path.size() == 1 && path[0] == XmlTagName::Metadata)
3570 result.Metadata = MetadataFromXml(reader);
3574 else if (node.Type == _internal::XmlNodeType::Text)
3576 if (path.size() == 1 && path[0] == XmlTagName::Deleted)
3578 result.Deleted = (std::strcmp(node.Value,
"true") == 0);
3580 else if (path.size() == 1 && path[0] == XmlTagName::Name)
3582 result.Name = node.Value;
3584 else if (path.size() == 1 && path[0] == XmlTagName::Snapshot)
3586 result.Snapshot = node.Value;
3588 else if (path.size() == 1 && path[0] == XmlTagName::Version)
3590 result.Version = node.Value;
3597 static ListSharesResponse ListSharesResponseFromXml(_internal::XmlReader& reader)
3599 auto result = ListSharesResponse();
3600 enum class XmlTagName
3610 std::vector<XmlTagName> path;
3614 auto node = reader.Read();
3615 if (node.Type == _internal::XmlNodeType::End)
3619 else if (node.Type == _internal::XmlNodeType::EndTag)
3621 if (path.size() > 0)
3630 else if (node.Type == _internal::XmlNodeType::StartTag)
3633 if (std::strcmp(node.Name,
"EnumerationResults") == 0)
3635 path.emplace_back(XmlTagName::EnumerationResults);
3637 else if (std::strcmp(node.Name,
"MaxResults") == 0)
3639 path.emplace_back(XmlTagName::MaxResults);
3641 else if (std::strcmp(node.Name,
"NextMarker") == 0)
3643 path.emplace_back(XmlTagName::NextMarker);
3645 else if (std::strcmp(node.Name,
"Prefix") == 0)
3647 path.emplace_back(XmlTagName::Prefix);
3649 else if (std::strcmp(node.Name,
"Share") == 0)
3651 path.emplace_back(XmlTagName::Share);
3653 else if (std::strcmp(node.Name,
"Shares") == 0)
3655 path.emplace_back(XmlTagName::Shares);
3659 path.emplace_back(XmlTagName::Unknown);
3661 if (path.size() == 3 && path[0] == XmlTagName::EnumerationResults
3662 && path[1] == XmlTagName::Shares && path[2] == XmlTagName::Share)
3664 result.Items.emplace_back(ShareItemFromXml(reader));
3668 else if (node.Type == _internal::XmlNodeType::Text)
3670 if (path.size() == 2 && path[0] == XmlTagName::EnumerationResults
3671 && path[1] == XmlTagName::NextMarker)
3673 result.ContinuationToken = node.Value;
3676 path.size() == 2 && path[0] == XmlTagName::EnumerationResults
3677 && path[1] == XmlTagName::MaxResults)
3679 result.PageSizeHint = std::stoi(node.Value);
3682 path.size() == 2 && path[0] == XmlTagName::EnumerationResults
3683 && path[1] == XmlTagName::Prefix)
3685 result.Prefix = node.Value;
3688 else if (node.Type == _internal::XmlNodeType::Attribute)
3690 if (path.size() == 1 && path[0] == XmlTagName::EnumerationResults
3691 && (std::strcmp(node.Name,
"ServiceEndpoint") == 0))
3693 result.ServiceEndpoint = node.Value;
3700 static ServiceListSharesSinglePageResult
3701 ServiceListSharesSinglePageResultFromListSharesResponse(ListSharesResponse
object)
3703 ServiceListSharesSinglePageResult result;
3704 result.ServiceEndpoint = std::move(
object.ServiceEndpoint);
3705 result.Prefix = std::move(
object.Prefix);
3706 result.PageSizeHint =
object.PageSizeHint;
3707 result.Items = std::move(
object.Items);
3708 result.ContinuationToken = std::move(
object.ContinuationToken);
3716 struct CreateOptions final
3718 Azure::Nullable<int32_t> Timeout;
3719 Storage::Metadata Metadata;
3720 Azure::Nullable<int64_t> ShareQuota;
3721 Azure::Nullable<AccessTier> XMsAccessTier;
3722 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
3725 static Azure::Response<Models::CreateShareResult> Create(
3726 const Azure::Core::Url& url,
3727 Azure::Core::Http::_internal::HttpPipeline& pipeline,
3728 Azure::Core::Context context,
3729 const CreateOptions& createOptions)
3731 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
3732 request.SetHeader(_detail::HeaderContentLength,
"0");
3733 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
3734 if (createOptions.Timeout.HasValue())
3736 request.GetUrl().AppendQueryParameter(
3737 _detail::QueryTimeout,
3738 _internal::UrlEncodeQueryParameter(std::to_string(createOptions.Timeout.Value())));
3740 for (
const auto& pair : createOptions.Metadata)
3742 request.SetHeader(_detail::HeaderMetadata + (
"-" + pair.first), pair.second);
3744 if (createOptions.ShareQuota.HasValue())
3747 _detail::HeaderQuota, std::to_string(createOptions.ShareQuota.Value()));
3749 if (createOptions.XMsAccessTier.HasValue())
3752 _detail::HeaderAccessTier, createOptions.XMsAccessTier.Value().ToString());
3754 request.SetHeader(_detail::HeaderVersion, createOptions.ApiVersionParameter);
3755 return CreateParseResult(context, pipeline.Send(request, context));
3758 struct GetPropertiesOptions final
3760 Azure::Nullable<std::string> ShareSnapshot;
3761 Azure::Nullable<int32_t> Timeout;
3762 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
3763 Azure::Nullable<std::string> LeaseIdOptional;
3766 static Azure::Response<Models::ShareProperties> GetProperties(
3767 const Azure::Core::Url& url,
3768 Azure::Core::Http::_internal::HttpPipeline& pipeline,
3769 Azure::Core::Context context,
3770 const GetPropertiesOptions& getPropertiesOptions)
3772 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
3773 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
3774 if (getPropertiesOptions.ShareSnapshot.HasValue())
3776 request.GetUrl().AppendQueryParameter(
3777 _detail::QueryShareSnapshot,
3778 _internal::UrlEncodeQueryParameter(getPropertiesOptions.ShareSnapshot.Value()));
3780 if (getPropertiesOptions.Timeout.HasValue())
3782 request.GetUrl().AppendQueryParameter(
3783 _detail::QueryTimeout,
3784 _internal::UrlEncodeQueryParameter(
3785 std::to_string(getPropertiesOptions.Timeout.Value())));
3787 request.SetHeader(_detail::HeaderVersion, getPropertiesOptions.ApiVersionParameter);
3788 if (getPropertiesOptions.LeaseIdOptional.HasValue())
3790 request.SetHeader(_detail::HeaderLeaseId, getPropertiesOptions.LeaseIdOptional.Value());
3792 return GetPropertiesParseResult(context, pipeline.Send(request, context));
3795 struct DeleteOptions final
3797 Azure::Nullable<std::string> ShareSnapshot;
3798 Azure::Nullable<int32_t> Timeout;
3799 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
3800 Azure::Nullable<DeleteSnapshotsOption> XMsDeleteSnapshots;
3801 Azure::Nullable<std::string> LeaseIdOptional;
3804 static Azure::Response<Models::DeleteShareResult> Delete(
3805 const Azure::Core::Url& url,
3806 Azure::Core::Http::_internal::HttpPipeline& pipeline,
3807 Azure::Core::Context context,
3808 const DeleteOptions& deleteOptions)
3810 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Delete, url);
3811 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
3812 if (deleteOptions.ShareSnapshot.HasValue())
3814 request.GetUrl().AppendQueryParameter(
3815 _detail::QueryShareSnapshot,
3816 _internal::UrlEncodeQueryParameter(deleteOptions.ShareSnapshot.Value()));
3818 if (deleteOptions.Timeout.HasValue())
3820 request.GetUrl().AppendQueryParameter(
3821 _detail::QueryTimeout,
3822 _internal::UrlEncodeQueryParameter(std::to_string(deleteOptions.Timeout.Value())));
3824 request.SetHeader(_detail::HeaderVersion, deleteOptions.ApiVersionParameter);
3825 if (deleteOptions.XMsDeleteSnapshots.HasValue())
3828 _detail::HeaderDeleteSnapshots,
3829 deleteOptions.XMsDeleteSnapshots.Value().ToString());
3831 if (deleteOptions.LeaseIdOptional.HasValue())
3833 request.SetHeader(_detail::HeaderLeaseId, deleteOptions.LeaseIdOptional.Value());
3835 return DeleteParseResult(context, pipeline.Send(request, context));
3838 struct AcquireLeaseOptions final
3840 Azure::Nullable<int32_t> Timeout;
3841 int32_t LeaseDuration = int32_t();
3842 Azure::Nullable<std::string> ProposedLeaseIdOptional;
3843 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
3844 Azure::Nullable<std::string> ShareSnapshot;
3847 static Azure::Response<Models::AcquireLeaseResult> AcquireLease(
3848 const Azure::Core::Url& url,
3849 Azure::Core::Http::_internal::HttpPipeline& pipeline,
3850 Azure::Core::Context context,
3851 const AcquireLeaseOptions& acquireLeaseOptions)
3853 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
3854 request.SetHeader(_detail::HeaderContentLength,
"0");
3855 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"lease");
3856 request.SetHeader(_detail::HeaderAction,
"acquire");
3857 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
3858 if (acquireLeaseOptions.Timeout.HasValue())
3860 request.GetUrl().AppendQueryParameter(
3861 _detail::QueryTimeout,
3862 _internal::UrlEncodeQueryParameter(
3863 std::to_string(acquireLeaseOptions.Timeout.Value())));
3866 _detail::HeaderDuration, std::to_string(acquireLeaseOptions.LeaseDuration));
3867 if (acquireLeaseOptions.ProposedLeaseIdOptional.HasValue())
3870 _detail::HeaderProposedLeaseId,
3871 acquireLeaseOptions.ProposedLeaseIdOptional.Value());
3873 request.SetHeader(_detail::HeaderVersion, acquireLeaseOptions.ApiVersionParameter);
3874 if (acquireLeaseOptions.ShareSnapshot.HasValue())
3876 request.GetUrl().AppendQueryParameter(
3877 _detail::QueryShareSnapshot,
3878 _internal::UrlEncodeQueryParameter(acquireLeaseOptions.ShareSnapshot.Value()));
3880 return AcquireLeaseParseResult(context, pipeline.Send(request, context));
3883 struct ReleaseLeaseOptions final
3885 Azure::Nullable<int32_t> Timeout;
3886 std::string LeaseIdRequired;
3887 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
3888 Azure::Nullable<std::string> ShareSnapshot;
3891 static Azure::Response<Models::ReleaseLeaseResult> ReleaseLease(
3892 const Azure::Core::Url& url,
3893 Azure::Core::Http::_internal::HttpPipeline& pipeline,
3894 Azure::Core::Context context,
3895 const ReleaseLeaseOptions& releaseLeaseOptions)
3897 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
3898 request.SetHeader(_detail::HeaderContentLength,
"0");
3899 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"lease");
3900 request.SetHeader(_detail::HeaderAction,
"release");
3901 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
3902 if (releaseLeaseOptions.Timeout.HasValue())
3904 request.GetUrl().AppendQueryParameter(
3905 _detail::QueryTimeout,
3906 _internal::UrlEncodeQueryParameter(
3907 std::to_string(releaseLeaseOptions.Timeout.Value())));
3909 request.SetHeader(_detail::HeaderLeaseId, releaseLeaseOptions.LeaseIdRequired);
3910 request.SetHeader(_detail::HeaderVersion, releaseLeaseOptions.ApiVersionParameter);
3911 if (releaseLeaseOptions.ShareSnapshot.HasValue())
3913 request.GetUrl().AppendQueryParameter(
3914 _detail::QueryShareSnapshot,
3915 _internal::UrlEncodeQueryParameter(releaseLeaseOptions.ShareSnapshot.Value()));
3917 return ReleaseLeaseParseResult(context, pipeline.Send(request, context));
3920 struct ChangeLeaseOptions final
3922 Azure::Nullable<int32_t> Timeout;
3923 std::string LeaseIdRequired;
3924 Azure::Nullable<std::string> ProposedLeaseIdOptional;
3925 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
3926 Azure::Nullable<std::string> ShareSnapshot;
3929 static Azure::Response<Models::ChangeLeaseResult> ChangeLease(
3930 const Azure::Core::Url& url,
3931 Azure::Core::Http::_internal::HttpPipeline& pipeline,
3932 Azure::Core::Context context,
3933 const ChangeLeaseOptions& changeLeaseOptions)
3935 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
3936 request.SetHeader(_detail::HeaderContentLength,
"0");
3937 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"lease");
3938 request.SetHeader(_detail::HeaderAction,
"change");
3939 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
3940 if (changeLeaseOptions.Timeout.HasValue())
3942 request.GetUrl().AppendQueryParameter(
3943 _detail::QueryTimeout,
3944 _internal::UrlEncodeQueryParameter(
3945 std::to_string(changeLeaseOptions.Timeout.Value())));
3947 request.SetHeader(_detail::HeaderLeaseId, changeLeaseOptions.LeaseIdRequired);
3948 if (changeLeaseOptions.ProposedLeaseIdOptional.HasValue())
3951 _detail::HeaderProposedLeaseId, changeLeaseOptions.ProposedLeaseIdOptional.Value());
3953 request.SetHeader(_detail::HeaderVersion, changeLeaseOptions.ApiVersionParameter);
3954 if (changeLeaseOptions.ShareSnapshot.HasValue())
3956 request.GetUrl().AppendQueryParameter(
3957 _detail::QueryShareSnapshot,
3958 _internal::UrlEncodeQueryParameter(changeLeaseOptions.ShareSnapshot.Value()));
3960 return ChangeLeaseParseResult(context, pipeline.Send(request, context));
3963 struct RenewLeaseOptions final
3965 Azure::Nullable<int32_t> Timeout;
3966 std::string LeaseIdRequired;
3967 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
3968 Azure::Nullable<std::string> ShareSnapshot;
3971 static Azure::Response<Models::RenewLeaseResult> RenewLease(
3972 const Azure::Core::Url& url,
3973 Azure::Core::Http::_internal::HttpPipeline& pipeline,
3974 Azure::Core::Context context,
3975 const RenewLeaseOptions& renewLeaseOptions)
3977 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
3978 request.SetHeader(_detail::HeaderContentLength,
"0");
3979 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"lease");
3980 request.SetHeader(_detail::HeaderAction,
"renew");
3981 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
3982 if (renewLeaseOptions.Timeout.HasValue())
3984 request.GetUrl().AppendQueryParameter(
3985 _detail::QueryTimeout,
3986 _internal::UrlEncodeQueryParameter(
3987 std::to_string(renewLeaseOptions.Timeout.Value())));
3989 request.SetHeader(_detail::HeaderLeaseId, renewLeaseOptions.LeaseIdRequired);
3990 request.SetHeader(_detail::HeaderVersion, renewLeaseOptions.ApiVersionParameter);
3991 if (renewLeaseOptions.ShareSnapshot.HasValue())
3993 request.GetUrl().AppendQueryParameter(
3994 _detail::QueryShareSnapshot,
3995 _internal::UrlEncodeQueryParameter(renewLeaseOptions.ShareSnapshot.Value()));
3997 return RenewLeaseParseResult(context, pipeline.Send(request, context));
4000 struct BreakLeaseOptions final
4002 Azure::Nullable<int32_t> Timeout;
4003 Azure::Nullable<int32_t> LeaseBreakPeriod;
4004 Azure::Nullable<std::string> LeaseIdOptional;
4005 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4006 Azure::Nullable<std::string> ShareSnapshot;
4009 static Azure::Response<Models::BreakLeaseResult> BreakLease(
4010 const Azure::Core::Url& url,
4011 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4012 Azure::Core::Context context,
4013 const BreakLeaseOptions& breakLeaseOptions)
4015 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
4016 request.SetHeader(_detail::HeaderContentLength,
"0");
4017 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"lease");
4018 request.SetHeader(_detail::HeaderAction,
"break");
4019 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4020 if (breakLeaseOptions.Timeout.HasValue())
4022 request.GetUrl().AppendQueryParameter(
4023 _detail::QueryTimeout,
4024 _internal::UrlEncodeQueryParameter(
4025 std::to_string(breakLeaseOptions.Timeout.Value())));
4027 if (breakLeaseOptions.LeaseBreakPeriod.HasValue())
4030 _detail::HeaderBreakPeriod,
4031 std::to_string(breakLeaseOptions.LeaseBreakPeriod.Value()));
4033 if (breakLeaseOptions.LeaseIdOptional.HasValue())
4035 request.SetHeader(_detail::HeaderLeaseId, breakLeaseOptions.LeaseIdOptional.Value());
4037 request.SetHeader(_detail::HeaderVersion, breakLeaseOptions.ApiVersionParameter);
4038 if (breakLeaseOptions.ShareSnapshot.HasValue())
4040 request.GetUrl().AppendQueryParameter(
4041 _detail::QueryShareSnapshot,
4042 _internal::UrlEncodeQueryParameter(breakLeaseOptions.ShareSnapshot.Value()));
4044 return BreakLeaseParseResult(context, pipeline.Send(request, context));
4047 struct CreateSnapshotOptions final
4049 Azure::Nullable<int32_t> Timeout;
4050 Storage::Metadata Metadata;
4051 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4054 static Azure::Response<Models::CreateShareSnapshotResult> CreateSnapshot(
4055 const Azure::Core::Url& url,
4056 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4057 Azure::Core::Context context,
4058 const CreateSnapshotOptions& createSnapshotOptions)
4060 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
4061 request.SetHeader(_detail::HeaderContentLength,
"0");
4062 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4063 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"snapshot");
4064 if (createSnapshotOptions.Timeout.HasValue())
4066 request.GetUrl().AppendQueryParameter(
4067 _detail::QueryTimeout,
4068 _internal::UrlEncodeQueryParameter(
4069 std::to_string(createSnapshotOptions.Timeout.Value())));
4071 for (
const auto& pair : createSnapshotOptions.Metadata)
4073 request.SetHeader(_detail::HeaderMetadata + (
"-" + pair.first), pair.second);
4075 request.SetHeader(_detail::HeaderVersion, createSnapshotOptions.ApiVersionParameter);
4076 return CreateSnapshotParseResult(context, pipeline.Send(request, context));
4079 struct CreatePermissionOptions final
4081 Azure::Nullable<int32_t> Timeout;
4082 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4083 SharePermission Permission;
4086 static Azure::Response<Models::CreateSharePermissionResult> CreatePermission(
4087 const Azure::Core::Url& url,
4088 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4089 Azure::Core::Context context,
4090 const CreatePermissionOptions& createPermissionOptions)
4093 std::string json_body;
4095 Azure::Core::Json::_internal::json json;
4096 SharePermissionToJson(json, createPermissionOptions.Permission);
4097 json_body = json.dump();
4099 auto body = Azure::Core::IO::MemoryBodyStream(
4100 reinterpret_cast<const uint8_t*
>(json_body.data()), json_body.length());
4101 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &body);
4102 request.SetHeader(
"Content-Length", std::to_string(body.Length()));
4103 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4104 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"filepermission");
4105 if (createPermissionOptions.Timeout.HasValue())
4107 request.GetUrl().AppendQueryParameter(
4108 _detail::QueryTimeout,
4109 _internal::UrlEncodeQueryParameter(
4110 std::to_string(createPermissionOptions.Timeout.Value())));
4112 request.SetHeader(_detail::HeaderVersion, createPermissionOptions.ApiVersionParameter);
4113 return CreatePermissionParseResult(context, pipeline.Send(request, context));
4116 struct GetPermissionOptions final
4118 std::string FilePermissionKeyRequired;
4119 Azure::Nullable<int32_t> Timeout;
4120 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4123 static Azure::Response<ShareGetPermissionResult> GetPermission(
4124 const Azure::Core::Url& url,
4125 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4126 Azure::Core::Context context,
4127 const GetPermissionOptions& getPermissionOptions)
4129 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
4130 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4131 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"filepermission");
4133 _detail::HeaderFilePermissionKey, getPermissionOptions.FilePermissionKeyRequired);
4134 if (getPermissionOptions.Timeout.HasValue())
4136 request.GetUrl().AppendQueryParameter(
4137 _detail::QueryTimeout,
4138 _internal::UrlEncodeQueryParameter(
4139 std::to_string(getPermissionOptions.Timeout.Value())));
4141 request.SetHeader(_detail::HeaderVersion, getPermissionOptions.ApiVersionParameter);
4142 return GetPermissionParseResult(context, pipeline.Send(request, context));
4145 struct SetPropertiesOptions final
4147 Azure::Nullable<int32_t> Timeout;
4148 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4149 Azure::Nullable<int64_t> ShareQuota;
4150 Azure::Nullable<AccessTier> XMsAccessTier;
4151 Azure::Nullable<std::string> LeaseIdOptional;
4154 static Azure::Response<Models::SetSharePropertiesResult> SetProperties(
4155 const Azure::Core::Url& url,
4156 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4157 Azure::Core::Context context,
4158 const SetPropertiesOptions& setPropertiesOptions)
4160 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
4161 request.SetHeader(_detail::HeaderContentLength,
"0");
4162 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4163 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"properties");
4164 if (setPropertiesOptions.Timeout.HasValue())
4166 request.GetUrl().AppendQueryParameter(
4167 _detail::QueryTimeout,
4168 _internal::UrlEncodeQueryParameter(
4169 std::to_string(setPropertiesOptions.Timeout.Value())));
4171 request.SetHeader(_detail::HeaderVersion, setPropertiesOptions.ApiVersionParameter);
4172 if (setPropertiesOptions.ShareQuota.HasValue())
4175 _detail::HeaderQuota, std::to_string(setPropertiesOptions.ShareQuota.Value()));
4177 if (setPropertiesOptions.XMsAccessTier.HasValue())
4180 _detail::HeaderAccessTier, setPropertiesOptions.XMsAccessTier.Value().ToString());
4182 if (setPropertiesOptions.LeaseIdOptional.HasValue())
4184 request.SetHeader(_detail::HeaderLeaseId, setPropertiesOptions.LeaseIdOptional.Value());
4186 return SetPropertiesParseResult(context, pipeline.Send(request, context));
4189 struct SetMetadataOptions final
4191 Azure::Nullable<int32_t> Timeout;
4192 Storage::Metadata Metadata;
4193 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4194 Azure::Nullable<std::string> LeaseIdOptional;
4197 static Azure::Response<Models::SetShareMetadataResult> SetMetadata(
4198 const Azure::Core::Url& url,
4199 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4200 Azure::Core::Context context,
4201 const SetMetadataOptions& setMetadataOptions)
4203 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
4204 request.SetHeader(_detail::HeaderContentLength,
"0");
4205 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4206 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"metadata");
4207 if (setMetadataOptions.Timeout.HasValue())
4209 request.GetUrl().AppendQueryParameter(
4210 _detail::QueryTimeout,
4211 _internal::UrlEncodeQueryParameter(
4212 std::to_string(setMetadataOptions.Timeout.Value())));
4214 for (
const auto& pair : setMetadataOptions.Metadata)
4216 request.SetHeader(_detail::HeaderMetadata + (
"-" + pair.first), pair.second);
4218 request.SetHeader(_detail::HeaderVersion, setMetadataOptions.ApiVersionParameter);
4219 if (setMetadataOptions.LeaseIdOptional.HasValue())
4221 request.SetHeader(_detail::HeaderLeaseId, setMetadataOptions.LeaseIdOptional.Value());
4223 return SetMetadataParseResult(context, pipeline.Send(request, context));
4226 struct GetAccessPolicyOptions final
4228 Azure::Nullable<int32_t> Timeout;
4229 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4230 Azure::Nullable<std::string> LeaseIdOptional;
4233 static Azure::Response<Models::ShareAccessPolicy> GetAccessPolicy(
4234 const Azure::Core::Url& url,
4235 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4236 Azure::Core::Context context,
4237 const GetAccessPolicyOptions& getAccessPolicyOptions)
4239 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
4240 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4241 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"acl");
4242 if (getAccessPolicyOptions.Timeout.HasValue())
4244 request.GetUrl().AppendQueryParameter(
4245 _detail::QueryTimeout,
4246 _internal::UrlEncodeQueryParameter(
4247 std::to_string(getAccessPolicyOptions.Timeout.Value())));
4249 request.SetHeader(_detail::HeaderVersion, getAccessPolicyOptions.ApiVersionParameter);
4250 if (getAccessPolicyOptions.LeaseIdOptional.HasValue())
4253 _detail::HeaderLeaseId, getAccessPolicyOptions.LeaseIdOptional.Value());
4255 return GetAccessPolicyParseResult(context, pipeline.Send(request, context));
4258 struct SetAccessPolicyOptions final
4260 std::vector<SignedIdentifier> ShareAcl;
4261 Azure::Nullable<int32_t> Timeout;
4262 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4263 Azure::Nullable<std::string> LeaseIdOptional;
4266 static Azure::Response<Models::SetShareAccessPolicyResult> SetAccessPolicy(
4267 const Azure::Core::Url& url,
4268 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4269 Azure::Core::Context context,
4270 const SetAccessPolicyOptions& setAccessPolicyOptions)
4273 std::string xml_body;
4275 _internal::XmlWriter writer;
4276 SignedIdentifiersToXml(writer, setAccessPolicyOptions.ShareAcl);
4277 writer.Write(_internal::XmlNode{_internal::XmlNodeType::End});
4278 xml_body = writer.GetDocument();
4280 auto body = Azure::Core::IO::MemoryBodyStream(
4281 reinterpret_cast<const uint8_t*
>(xml_body.data()), xml_body.length());
4282 auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &body);
4283 request.SetHeader(
"Content-Length", std::to_string(body.Length()));
4284 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4285 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"acl");
4286 if (setAccessPolicyOptions.Timeout.HasValue())
4288 request.GetUrl().AppendQueryParameter(
4289 _detail::QueryTimeout,
4290 _internal::UrlEncodeQueryParameter(
4291 std::to_string(setAccessPolicyOptions.Timeout.Value())));
4293 request.SetHeader(_detail::HeaderVersion, setAccessPolicyOptions.ApiVersionParameter);
4294 if (setAccessPolicyOptions.LeaseIdOptional.HasValue())
4297 _detail::HeaderLeaseId, setAccessPolicyOptions.LeaseIdOptional.Value());
4299 return SetAccessPolicyParseResult(context, pipeline.Send(request, context));
4302 struct GetStatisticsOptions final
4304 Azure::Nullable<int32_t> Timeout;
4305 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4306 Azure::Nullable<std::string> LeaseIdOptional;
4309 static Azure::Response<Models::ShareStatistics> GetStatistics(
4310 const Azure::Core::Url& url,
4311 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4312 Azure::Core::Context context,
4313 const GetStatisticsOptions& getStatisticsOptions)
4315 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
4316 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4317 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"stats");
4318 if (getStatisticsOptions.Timeout.HasValue())
4320 request.GetUrl().AppendQueryParameter(
4321 _detail::QueryTimeout,
4322 _internal::UrlEncodeQueryParameter(
4323 std::to_string(getStatisticsOptions.Timeout.Value())));
4325 request.SetHeader(_detail::HeaderVersion, getStatisticsOptions.ApiVersionParameter);
4326 if (getStatisticsOptions.LeaseIdOptional.HasValue())
4328 request.SetHeader(_detail::HeaderLeaseId, getStatisticsOptions.LeaseIdOptional.Value());
4330 return GetStatisticsParseResult(context, pipeline.Send(request, context));
4333 struct RestoreOptions final
4335 Azure::Nullable<int32_t> Timeout;
4336 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
4337 Azure::Nullable<std::string> DeletedShareName;
4338 Azure::Nullable<std::string> DeletedShareVersion;
4341 static Azure::Response<ShareRestoreResult> Restore(
4342 const Azure::Core::Url& url,
4343 Azure::Core::Http::_internal::HttpPipeline& pipeline,
4344 Azure::Core::Context context,
4345 const RestoreOptions& restoreOptions)
4347 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
4348 request.SetHeader(_detail::HeaderContentLength,
"0");
4349 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"share");
4350 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"undelete");
4351 if (restoreOptions.Timeout.HasValue())
4353 request.GetUrl().AppendQueryParameter(
4354 _detail::QueryTimeout,
4355 _internal::UrlEncodeQueryParameter(std::to_string(restoreOptions.Timeout.Value())));
4357 request.SetHeader(_detail::HeaderVersion, restoreOptions.ApiVersionParameter);
4358 if (restoreOptions.DeletedShareName.HasValue())
4361 _detail::HeaderDeletedShareName, restoreOptions.DeletedShareName.Value());
4363 if (restoreOptions.DeletedShareVersion.HasValue())
4366 _detail::HeaderDeletedShareVersion, restoreOptions.DeletedShareVersion.Value());
4368 return RestoreParseResult(context, pipeline.Send(request, context));
4372 static Azure::Response<Models::CreateShareResult> CreateParseResult(
4373 Azure::Core::Context context,
4374 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4376 auto& response = *responsePtr;
4377 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
4380 Models::CreateShareResult result;
4381 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4382 result.LastModified = DateTime::Parse(
4383 response.GetHeaders().at(_detail::HeaderLastModified),
4384 DateTime::DateFormat::Rfc1123);
4385 return Azure::Response<Models::CreateShareResult>(
4386 std::move(result), std::move(responsePtr));
4391 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4395 static Azure::Response<Models::ShareProperties> GetPropertiesParseResult(
4396 Azure::Core::Context context,
4397 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4399 auto& response = *responsePtr;
4400 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
4403 Models::ShareProperties result;
4405 for (
auto i = response.GetHeaders().lower_bound(_detail::HeaderMetadata);
4406 i != response.GetHeaders().end()
4407 && i->first.substr(0, 9) == _detail::HeaderMetadata;
4410 result.Metadata.emplace(i->first.substr(10), i->second);
4412 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4413 result.LastModified = DateTime::Parse(
4414 response.GetHeaders().at(_detail::HeaderLastModified),
4415 DateTime::DateFormat::Rfc1123);
4416 result.Quota = std::stoll(response.GetHeaders().at(_detail::HeaderQuota));
4417 if (response.GetHeaders().find(_detail::HeaderProvisionedIops)
4418 != response.GetHeaders().end())
4420 result.ProvisionedIops
4421 = std::stoi(response.GetHeaders().at(_detail::HeaderProvisionedIops));
4423 if (response.GetHeaders().find(_detail::HeaderProvisionedIngressMBps)
4424 != response.GetHeaders().end())
4426 result.ProvisionedIngressMBps
4427 = std::stoi(response.GetHeaders().at(_detail::HeaderProvisionedIngressMBps));
4429 if (response.GetHeaders().find(_detail::HeaderProvisionedEgressMBps)
4430 != response.GetHeaders().end())
4432 result.ProvisionedEgressMBps
4433 = std::stoi(response.GetHeaders().at(_detail::HeaderProvisionedEgressMBps));
4435 if (response.GetHeaders().find(_detail::HeaderNextAllowedQuotaDowngradeTime)
4436 != response.GetHeaders().end())
4438 result.NextAllowedQuotaDowngradeTime = DateTime::Parse(
4439 response.GetHeaders().at(_detail::HeaderNextAllowedQuotaDowngradeTime),
4440 DateTime::DateFormat::Rfc1123);
4442 if (response.GetHeaders().find(_detail::HeaderLeaseDuration)
4443 != response.GetHeaders().end())
4445 result.LeaseDuration
4446 = LeaseDuration(response.GetHeaders().at(_detail::HeaderLeaseDuration));
4448 if (response.GetHeaders().find(_detail::HeaderLeaseState)
4449 != response.GetHeaders().end())
4451 result.LeaseState = LeaseState(response.GetHeaders().at(_detail::HeaderLeaseState));
4453 if (response.GetHeaders().find(_detail::HeaderLeaseStatus)
4454 != response.GetHeaders().end())
4457 = LeaseStatus(response.GetHeaders().at(_detail::HeaderLeaseStatus));
4459 if (response.GetHeaders().find(
"x-ms-access-tier") != response.GetHeaders().end())
4461 result.AccessTier = AccessTier(response.GetHeaders().at(
"x-ms-access-tier"));
4463 if (response.GetHeaders().find(_detail::HeaderAccessTierChangedOn)
4464 != response.GetHeaders().end())
4466 result.AccessTierChangedOn = DateTime::Parse(
4467 response.GetHeaders().at(_detail::HeaderAccessTierChangedOn),
4468 DateTime::DateFormat::Rfc1123);
4470 if (response.GetHeaders().find(_detail::HeaderAccessTierTransitionState)
4471 != response.GetHeaders().end())
4473 result.AccessTierTransitionState
4474 = response.GetHeaders().at(_detail::HeaderAccessTierTransitionState);
4476 return Azure::Response<Models::ShareProperties>(
4477 std::move(result), std::move(responsePtr));
4482 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4486 static Azure::Response<Models::DeleteShareResult> DeleteParseResult(
4487 Azure::Core::Context context,
4488 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4490 auto& response = *responsePtr;
4491 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)
4494 Models::DeleteShareResult result;
4495 return Azure::Response<Models::DeleteShareResult>(
4496 std::move(result), std::move(responsePtr));
4501 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4505 static Azure::Response<Models::AcquireLeaseResult> AcquireLeaseParseResult(
4506 Azure::Core::Context context,
4507 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4509 auto& response = *responsePtr;
4510 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
4513 Models::AcquireLeaseResult result;
4514 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4515 result.LastModified = DateTime::Parse(
4516 response.GetHeaders().at(_detail::HeaderLastModified),
4517 DateTime::DateFormat::Rfc1123);
4518 result.LeaseId = response.GetHeaders().at(_detail::HeaderLeaseId);
4519 return Azure::Response<Models::AcquireLeaseResult>(
4520 std::move(result), std::move(responsePtr));
4525 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4529 static Azure::Response<Models::ReleaseLeaseResult> ReleaseLeaseParseResult(
4530 Azure::Core::Context context,
4531 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4533 auto& response = *responsePtr;
4534 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
4537 Models::ReleaseLeaseResult result;
4538 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4539 result.LastModified = DateTime::Parse(
4540 response.GetHeaders().at(_detail::HeaderLastModified),
4541 DateTime::DateFormat::Rfc1123);
4542 return Azure::Response<Models::ReleaseLeaseResult>(
4543 std::move(result), std::move(responsePtr));
4548 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4552 static Azure::Response<Models::ChangeLeaseResult> ChangeLeaseParseResult(
4553 Azure::Core::Context context,
4554 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4556 auto& response = *responsePtr;
4557 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
4560 Models::ChangeLeaseResult result;
4561 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4562 result.LastModified = DateTime::Parse(
4563 response.GetHeaders().at(_detail::HeaderLastModified),
4564 DateTime::DateFormat::Rfc1123);
4565 result.LeaseId = response.GetHeaders().at(_detail::HeaderLeaseId);
4566 return Azure::Response<Models::ChangeLeaseResult>(
4567 std::move(result), std::move(responsePtr));
4572 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4576 static Azure::Response<Models::RenewLeaseResult> RenewLeaseParseResult(
4577 Azure::Core::Context context,
4578 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4580 auto& response = *responsePtr;
4581 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
4584 Models::RenewLeaseResult result;
4585 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4586 result.LastModified = DateTime::Parse(
4587 response.GetHeaders().at(_detail::HeaderLastModified),
4588 DateTime::DateFormat::Rfc1123);
4589 result.LeaseId = response.GetHeaders().at(_detail::HeaderLeaseId);
4590 return Azure::Response<Models::RenewLeaseResult>(
4591 std::move(result), std::move(responsePtr));
4596 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4600 static Azure::Response<Models::BreakLeaseResult> BreakLeaseParseResult(
4601 Azure::Core::Context context,
4602 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4604 auto& response = *responsePtr;
4605 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)
4608 Models::BreakLeaseResult result;
4609 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4610 result.LastModified = DateTime::Parse(
4611 response.GetHeaders().at(_detail::HeaderLastModified),
4612 DateTime::DateFormat::Rfc1123);
4613 return Azure::Response<Models::BreakLeaseResult>(
4614 std::move(result), std::move(responsePtr));
4619 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4623 static Azure::Response<Models::CreateShareSnapshotResult> CreateSnapshotParseResult(
4624 Azure::Core::Context context,
4625 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4627 auto& response = *responsePtr;
4628 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
4631 Models::CreateShareSnapshotResult result;
4632 result.Snapshot = response.GetHeaders().at(_detail::HeaderSnapshot);
4633 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4634 result.LastModified = DateTime::Parse(
4635 response.GetHeaders().at(_detail::HeaderLastModified),
4636 DateTime::DateFormat::Rfc1123);
4637 return Azure::Response<Models::CreateShareSnapshotResult>(
4638 std::move(result), std::move(responsePtr));
4643 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4647 static Azure::Response<Models::CreateSharePermissionResult> CreatePermissionParseResult(
4648 Azure::Core::Context context,
4649 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4651 auto& response = *responsePtr;
4652 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
4655 Models::CreateSharePermissionResult result;
4656 result.FilePermissionKey = response.GetHeaders().at(_detail::HeaderFilePermissionKey);
4657 return Azure::Response<Models::CreateSharePermissionResult>(
4658 std::move(result), std::move(responsePtr));
4663 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4667 static void SharePermissionToJson(
4668 Azure::Core::Json::_internal::json& node,
4669 const SharePermission&
object)
4671 node[
"permission"] =
object.FilePermission;
4674 static Azure::Response<ShareGetPermissionResult> GetPermissionParseResult(
4675 Azure::Core::Context context,
4676 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4678 auto& response = *responsePtr;
4679 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
4682 const auto& bodyBuffer = response.GetBody();
4683 ShareGetPermissionResult result = bodyBuffer.empty()
4684 ? ShareGetPermissionResult()
4685 : ShareGetPermissionResultFromSharePermission(
4686 SharePermissionFromJson(Azure::Core::Json::_internal::json::parse(bodyBuffer)));
4687 return Azure::Response<ShareGetPermissionResult>(
4688 std::move(result), std::move(responsePtr));
4693 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4697 static SharePermission SharePermissionFromJson(
4698 const Azure::Core::Json::_internal::json& node)
4700 SharePermission result;
4701 result.FilePermission = node[
"permission"].get<std::string>();
4705 static ShareGetPermissionResult ShareGetPermissionResultFromSharePermission(
4706 SharePermission
object)
4708 ShareGetPermissionResult result;
4709 result.FilePermission = std::move(
object.FilePermission);
4713 static Azure::Response<Models::SetSharePropertiesResult> SetPropertiesParseResult(
4714 Azure::Core::Context context,
4715 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4717 auto& response = *responsePtr;
4718 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
4721 Models::SetSharePropertiesResult result;
4722 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4723 result.LastModified = DateTime::Parse(
4724 response.GetHeaders().at(_detail::HeaderLastModified),
4725 DateTime::DateFormat::Rfc1123);
4726 return Azure::Response<Models::SetSharePropertiesResult>(
4727 std::move(result), std::move(responsePtr));
4732 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4736 static Azure::Response<Models::SetShareMetadataResult> SetMetadataParseResult(
4737 Azure::Core::Context context,
4738 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4740 auto& response = *responsePtr;
4741 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
4744 Models::SetShareMetadataResult result;
4745 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4746 result.LastModified = DateTime::Parse(
4747 response.GetHeaders().at(_detail::HeaderLastModified),
4748 DateTime::DateFormat::Rfc1123);
4749 return Azure::Response<Models::SetShareMetadataResult>(
4750 std::move(result), std::move(responsePtr));
4755 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4759 static Azure::Response<Models::ShareAccessPolicy> GetAccessPolicyParseResult(
4760 Azure::Core::Context context,
4761 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4763 auto& response = *responsePtr;
4764 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
4767 const auto& bodyBuffer = response.GetBody();
4768 auto reader = _internal::XmlReader(
4769 reinterpret_cast<const char*
>(bodyBuffer.data()), bodyBuffer.size());
4770 Models::ShareAccessPolicy result = bodyBuffer.empty()
4771 ? Models::ShareAccessPolicy()
4772 : ShareAccessPolicyFromSignedIdentifiers(SignedIdentifiersFromXml(reader));
4773 return Azure::Response<Models::ShareAccessPolicy>(
4774 std::move(result), std::move(responsePtr));
4779 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
4783 static AccessPolicy AccessPolicyFromXml(_internal::XmlReader& reader)
4785 auto result = AccessPolicy();
4786 enum class XmlTagName
4793 std::vector<XmlTagName> path;
4797 auto node = reader.Read();
4798 if (node.Type == _internal::XmlNodeType::End)
4802 else if (node.Type == _internal::XmlNodeType::EndTag)
4804 if (path.size() > 0)
4813 else if (node.Type == _internal::XmlNodeType::StartTag)
4816 if (std::strcmp(node.Name,
"Expiry") == 0)
4818 path.emplace_back(XmlTagName::Expiry);
4820 else if (std::strcmp(node.Name,
"Permission") == 0)
4822 path.emplace_back(XmlTagName::Permission);
4824 else if (std::strcmp(node.Name,
"Start") == 0)
4826 path.emplace_back(XmlTagName::Start);
4830 path.emplace_back(XmlTagName::Unknown);
4833 else if (node.Type == _internal::XmlNodeType::Text)
4835 if (path.size() == 1 && path[0] == XmlTagName::Expiry)
4837 result.ExpiresOn = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc3339);
4839 else if (path.size() == 1 && path[0] == XmlTagName::Permission)
4841 result.Permission = node.Value;
4843 else if (path.size() == 1 && path[0] == XmlTagName::Start)
4845 result.StartsOn = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc3339);
4852 static SignedIdentifier SignedIdentifierFromXml(_internal::XmlReader& reader)
4854 auto result = SignedIdentifier();
4855 enum class XmlTagName
4861 std::vector<XmlTagName> path;
4865 auto node = reader.Read();
4866 if (node.Type == _internal::XmlNodeType::End)
4870 else if (node.Type == _internal::XmlNodeType::EndTag)
4872 if (path.size() > 0)
4881 else if (node.Type == _internal::XmlNodeType::StartTag)
4884 if (std::strcmp(node.Name,
"AccessPolicy") == 0)
4886 path.emplace_back(XmlTagName::AccessPolicy);
4888 else if (std::strcmp(node.Name,
"Id") == 0)
4890 path.emplace_back(XmlTagName::Id);
4894 path.emplace_back(XmlTagName::Unknown);
4897 if (path.size() == 1 && path[0] == XmlTagName::AccessPolicy)
4899 result.Policy = AccessPolicyFromXml(reader);
4903 else if (node.Type == _internal::XmlNodeType::Text)
4905 if (path.size() == 1 && path[0] == XmlTagName::Id)
4907 result.Id = node.Value;
4914 static std::vector<SignedIdentifier> SignedIdentifiersFromXml(_internal::XmlReader& reader)
4916 auto result = std::vector<SignedIdentifier>();
4917 enum class XmlTagName
4923 std::vector<XmlTagName> path;
4927 auto node = reader.Read();
4928 if (node.Type == _internal::XmlNodeType::End)
4932 else if (node.Type == _internal::XmlNodeType::EndTag)
4934 if (path.size() > 0)
4943 else if (node.Type == _internal::XmlNodeType::StartTag)
4946 if (std::strcmp(node.Name,
"SignedIdentifier") == 0)
4948 path.emplace_back(XmlTagName::SignedIdentifier);
4950 else if (std::strcmp(node.Name,
"SignedIdentifiers") == 0)
4952 path.emplace_back(XmlTagName::SignedIdentifiers);
4956 path.emplace_back(XmlTagName::Unknown);
4959 if (path.size() == 2 && path[0] == XmlTagName::SignedIdentifiers
4960 && path[1] == XmlTagName::SignedIdentifier)
4962 result.emplace_back(SignedIdentifierFromXml(reader));
4966 else if (node.Type == _internal::XmlNodeType::Text)
4973 static Models::ShareAccessPolicy ShareAccessPolicyFromSignedIdentifiers(
4974 std::vector<SignedIdentifier>
object)
4976 Models::ShareAccessPolicy result;
4977 result.SignedIdentifiers = std::move(
object);
4981 static Azure::Response<Models::SetShareAccessPolicyResult> SetAccessPolicyParseResult(
4982 Azure::Core::Context context,
4983 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
4985 auto& response = *responsePtr;
4986 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
4989 Models::SetShareAccessPolicyResult result;
4990 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
4991 result.LastModified = DateTime::Parse(
4992 response.GetHeaders().at(_detail::HeaderLastModified),
4993 DateTime::DateFormat::Rfc1123);
4994 return Azure::Response<Models::SetShareAccessPolicyResult>(
4995 std::move(result), std::move(responsePtr));
5000 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
5004 static void AccessPolicyToXml(_internal::XmlWriter& writer,
const AccessPolicy&
object)
5006 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"AccessPolicy"});
5007 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Start"});
5008 writer.Write(_internal::XmlNode{
5009 _internal::XmlNodeType::Text,
5013 Azure::DateTime::DateFormat::Rfc3339, DateTime::TimeFractionFormat::AllDigits)
5015 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
5016 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Expiry"});
5017 writer.Write(_internal::XmlNode{
5018 _internal::XmlNodeType::Text,
5022 Azure::DateTime::DateFormat::Rfc3339, DateTime::TimeFractionFormat::AllDigits)
5024 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
5025 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Permission"});
5027 _internal::XmlNode{_internal::XmlNodeType::Text,
nullptr,
object.Permission.data()});
5028 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
5029 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
5032 static void SignedIdentifierToXml(
5033 _internal::XmlWriter& writer,
5034 const SignedIdentifier&
object)
5036 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"SignedIdentifier"});
5037 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"Id"});
5038 writer.Write(_internal::XmlNode{_internal::XmlNodeType::Text,
nullptr,
object.Id.data()});
5039 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
5040 AccessPolicyToXml(writer,
object.Policy);
5041 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
5044 static void SignedIdentifiersToXml(
5045 _internal::XmlWriter& writer,
5046 const std::vector<SignedIdentifier>&
object)
5048 writer.Write(_internal::XmlNode{_internal::XmlNodeType::StartTag,
"SignedIdentifiers"});
5049 for (
const auto& item :
object)
5051 SignedIdentifierToXml(writer, item);
5053 writer.Write(_internal::XmlNode{_internal::XmlNodeType::EndTag});
5055 static Azure::Response<Models::ShareStatistics> GetStatisticsParseResult(
5056 Azure::Core::Context context,
5057 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
5059 auto& response = *responsePtr;
5060 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
5063 const auto& bodyBuffer = response.GetBody();
5064 auto reader = _internal::XmlReader(
5065 reinterpret_cast<const char*
>(bodyBuffer.data()), bodyBuffer.size());
5066 Models::ShareStatistics result = bodyBuffer.empty()
5067 ? Models::ShareStatistics()
5068 : ShareStatisticsFromShareStats(ShareStatsFromXml(reader));
5069 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
5070 result.LastModified = DateTime::Parse(
5071 response.GetHeaders().at(_detail::HeaderLastModified),
5072 DateTime::DateFormat::Rfc1123);
5073 return Azure::Response<Models::ShareStatistics>(
5074 std::move(result), std::move(responsePtr));
5079 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
5083 static ShareStats ShareStatsFromXml(_internal::XmlReader& reader)
5085 auto result = ShareStats();
5086 enum class XmlTagName
5092 std::vector<XmlTagName> path;
5096 auto node = reader.Read();
5097 if (node.Type == _internal::XmlNodeType::End)
5101 else if (node.Type == _internal::XmlNodeType::EndTag)
5103 if (path.size() > 0)
5112 else if (node.Type == _internal::XmlNodeType::StartTag)
5115 if (std::strcmp(node.Name,
"ShareStats") == 0)
5117 path.emplace_back(XmlTagName::ShareStats);
5119 else if (std::strcmp(node.Name,
"ShareUsageBytes") == 0)
5121 path.emplace_back(XmlTagName::ShareUsageBytes);
5125 path.emplace_back(XmlTagName::Unknown);
5128 else if (node.Type == _internal::XmlNodeType::Text)
5130 if (path.size() == 2 && path[0] == XmlTagName::ShareStats
5131 && path[1] == XmlTagName::ShareUsageBytes)
5133 result.ShareUsageInBytes = std::stoll(node.Value);
5140 static Models::ShareStatistics ShareStatisticsFromShareStats(ShareStats
object)
5142 Models::ShareStatistics result;
5143 result.ShareUsageInBytes =
object.ShareUsageInBytes;
5147 static Azure::Response<ShareRestoreResult> RestoreParseResult(
5148 Azure::Core::Context context,
5149 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
5151 auto& response = *responsePtr;
5152 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
5155 ShareRestoreResult result;
5156 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
5157 result.LastModified = DateTime::Parse(
5158 response.GetHeaders().at(_detail::HeaderLastModified),
5159 DateTime::DateFormat::Rfc1123);
5160 return Azure::Response<ShareRestoreResult>(std::move(result), std::move(responsePtr));
5165 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
5170 class Directory final {
5172 struct CreateOptions final
5174 Azure::Nullable<int32_t> Timeout;
5175 Storage::Metadata Metadata;
5176 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
5177 Azure::Nullable<std::string> FilePermission;
5178 Azure::Nullable<std::string> FilePermissionKey;
5179 std::string FileAttributes;
5180 std::string FileCreationTime;
5181 std::string FileLastWriteTime;
5184 static Azure::Response<Models::CreateDirectoryResult> Create(
5185 const Azure::Core::Url& url,
5186 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5187 Azure::Core::Context context,
5188 const CreateOptions& createOptions)
5190 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
5191 request.SetHeader(_detail::HeaderContentLength,
"0");
5192 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"directory");
5193 if (createOptions.Timeout.HasValue())
5195 request.GetUrl().AppendQueryParameter(
5196 _detail::QueryTimeout,
5197 _internal::UrlEncodeQueryParameter(std::to_string(createOptions.Timeout.Value())));
5199 for (
const auto& pair : createOptions.Metadata)
5201 request.SetHeader(_detail::HeaderMetadata + (
"-" + pair.first), pair.second);
5203 request.SetHeader(_detail::HeaderVersion, createOptions.ApiVersionParameter);
5204 if (createOptions.FilePermission.HasValue())
5206 request.SetHeader(_detail::HeaderFilePermission, createOptions.FilePermission.Value());
5208 if (createOptions.FilePermissionKey.HasValue())
5211 _detail::HeaderFilePermissionKey, createOptions.FilePermissionKey.Value());
5213 request.SetHeader(_detail::HeaderFileAttributes, createOptions.FileAttributes);
5214 request.SetHeader(_detail::HeaderFileCreatedOn, createOptions.FileCreationTime);
5215 request.SetHeader(_detail::HeaderFileLastWrittenOn, createOptions.FileLastWriteTime);
5216 return CreateParseResult(context, pipeline.Send(request, context));
5219 struct GetPropertiesOptions final
5221 Azure::Nullable<std::string> ShareSnapshot;
5222 Azure::Nullable<int32_t> Timeout;
5223 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
5226 static Azure::Response<Models::DirectoryProperties> GetProperties(
5227 const Azure::Core::Url& url,
5228 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5229 Azure::Core::Context context,
5230 const GetPropertiesOptions& getPropertiesOptions)
5232 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
5233 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"directory");
5234 if (getPropertiesOptions.ShareSnapshot.HasValue())
5236 request.GetUrl().AppendQueryParameter(
5237 _detail::QueryShareSnapshot,
5238 _internal::UrlEncodeQueryParameter(getPropertiesOptions.ShareSnapshot.Value()));
5240 if (getPropertiesOptions.Timeout.HasValue())
5242 request.GetUrl().AppendQueryParameter(
5243 _detail::QueryTimeout,
5244 _internal::UrlEncodeQueryParameter(
5245 std::to_string(getPropertiesOptions.Timeout.Value())));
5247 request.SetHeader(_detail::HeaderVersion, getPropertiesOptions.ApiVersionParameter);
5248 return GetPropertiesParseResult(context, pipeline.Send(request, context));
5251 struct DeleteOptions final
5253 Azure::Nullable<int32_t> Timeout;
5254 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
5257 static Azure::Response<Models::DeleteDirectoryResult> Delete(
5258 const Azure::Core::Url& url,
5259 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5260 Azure::Core::Context context,
5261 const DeleteOptions& deleteOptions)
5263 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Delete, url);
5264 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"directory");
5265 if (deleteOptions.Timeout.HasValue())
5267 request.GetUrl().AppendQueryParameter(
5268 _detail::QueryTimeout,
5269 _internal::UrlEncodeQueryParameter(std::to_string(deleteOptions.Timeout.Value())));
5271 request.SetHeader(_detail::HeaderVersion, deleteOptions.ApiVersionParameter);
5272 return DeleteParseResult(context, pipeline.Send(request, context));
5275 struct SetPropertiesOptions final
5277 Azure::Nullable<int32_t> Timeout;
5278 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
5279 Azure::Nullable<std::string> FilePermission;
5280 Azure::Nullable<std::string> FilePermissionKey;
5281 std::string FileAttributes;
5282 std::string FileCreationTime;
5283 std::string FileLastWriteTime;
5286 static Azure::Response<Models::SetDirectoryPropertiesResult> SetProperties(
5287 const Azure::Core::Url& url,
5288 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5289 Azure::Core::Context context,
5290 const SetPropertiesOptions& setPropertiesOptions)
5292 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
5293 request.SetHeader(_detail::HeaderContentLength,
"0");
5294 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"directory");
5295 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"properties");
5296 if (setPropertiesOptions.Timeout.HasValue())
5298 request.GetUrl().AppendQueryParameter(
5299 _detail::QueryTimeout,
5300 _internal::UrlEncodeQueryParameter(
5301 std::to_string(setPropertiesOptions.Timeout.Value())));
5303 request.SetHeader(_detail::HeaderVersion, setPropertiesOptions.ApiVersionParameter);
5304 if (setPropertiesOptions.FilePermission.HasValue())
5307 _detail::HeaderFilePermission, setPropertiesOptions.FilePermission.Value());
5309 if (setPropertiesOptions.FilePermissionKey.HasValue())
5312 _detail::HeaderFilePermissionKey, setPropertiesOptions.FilePermissionKey.Value());
5314 request.SetHeader(_detail::HeaderFileAttributes, setPropertiesOptions.FileAttributes);
5315 request.SetHeader(_detail::HeaderFileCreatedOn, setPropertiesOptions.FileCreationTime);
5317 _detail::HeaderFileLastWrittenOn, setPropertiesOptions.FileLastWriteTime);
5318 return SetPropertiesParseResult(context, pipeline.Send(request, context));
5321 struct SetMetadataOptions final
5323 Azure::Nullable<int32_t> Timeout;
5324 Storage::Metadata Metadata;
5325 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
5328 static Azure::Response<Models::SetDirectoryMetadataResult> SetMetadata(
5329 const Azure::Core::Url& url,
5330 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5331 Azure::Core::Context context,
5332 const SetMetadataOptions& setMetadataOptions)
5334 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
5335 request.SetHeader(_detail::HeaderContentLength,
"0");
5336 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"directory");
5337 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"metadata");
5338 if (setMetadataOptions.Timeout.HasValue())
5340 request.GetUrl().AppendQueryParameter(
5341 _detail::QueryTimeout,
5342 _internal::UrlEncodeQueryParameter(
5343 std::to_string(setMetadataOptions.Timeout.Value())));
5345 for (
const auto& pair : setMetadataOptions.Metadata)
5347 request.SetHeader(_detail::HeaderMetadata + (
"-" + pair.first), pair.second);
5349 request.SetHeader(_detail::HeaderVersion, setMetadataOptions.ApiVersionParameter);
5350 return SetMetadataParseResult(context, pipeline.Send(request, context));
5353 struct ListFilesAndDirectoriesSinglePageOptions final
5355 Azure::Nullable<std::string> Prefix;
5356 Azure::Nullable<std::string> ShareSnapshot;
5357 Azure::Nullable<std::string> ContinuationToken;
5358 Azure::Nullable<int32_t> MaxResults;
5359 Azure::Nullable<int32_t> Timeout;
5360 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
5363 static Azure::Response<DirectoryListFilesAndDirectoriesSinglePageResult>
5364 ListFilesAndDirectoriesSinglePage(
5365 const Azure::Core::Url& url,
5366 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5367 Azure::Core::Context context,
5368 const ListFilesAndDirectoriesSinglePageOptions&
5369 listFilesAndDirectoriesSinglePageOptions)
5371 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
5372 request.GetUrl().AppendQueryParameter(_detail::QueryRestype,
"directory");
5373 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"list");
5374 if (listFilesAndDirectoriesSinglePageOptions.Prefix.HasValue())
5376 request.GetUrl().AppendQueryParameter(
5377 _detail::QueryPrefix,
5378 _internal::UrlEncodeQueryParameter(
5379 listFilesAndDirectoriesSinglePageOptions.Prefix.Value()));
5381 if (listFilesAndDirectoriesSinglePageOptions.ShareSnapshot.HasValue())
5383 request.GetUrl().AppendQueryParameter(
5384 _detail::QueryShareSnapshot,
5385 _internal::UrlEncodeQueryParameter(
5386 listFilesAndDirectoriesSinglePageOptions.ShareSnapshot.Value()));
5388 if (listFilesAndDirectoriesSinglePageOptions.ContinuationToken.HasValue())
5390 request.GetUrl().AppendQueryParameter(
5391 _detail::QueryContinuationToken,
5392 _internal::UrlEncodeQueryParameter(
5393 listFilesAndDirectoriesSinglePageOptions.ContinuationToken.Value()));
5395 if (listFilesAndDirectoriesSinglePageOptions.MaxResults.HasValue())
5397 request.GetUrl().AppendQueryParameter(
5398 _detail::QueryPageSizeHint,
5399 _internal::UrlEncodeQueryParameter(
5400 std::to_string(listFilesAndDirectoriesSinglePageOptions.MaxResults.Value())));
5402 if (listFilesAndDirectoriesSinglePageOptions.Timeout.HasValue())
5404 request.GetUrl().AppendQueryParameter(
5405 _detail::QueryTimeout,
5406 _internal::UrlEncodeQueryParameter(
5407 std::to_string(listFilesAndDirectoriesSinglePageOptions.Timeout.Value())));
5410 _detail::HeaderVersion, listFilesAndDirectoriesSinglePageOptions.ApiVersionParameter);
5411 return ListFilesAndDirectoriesSinglePageParseResult(
5412 context, pipeline.Send(request, context));
5415 struct ListHandlesOptions final
5417 Azure::Nullable<std::string> ContinuationToken;
5418 Azure::Nullable<int32_t> MaxResults;
5419 Azure::Nullable<int32_t> Timeout;
5420 Azure::Nullable<std::string> ShareSnapshot;
5421 Azure::Nullable<bool> Recursive;
5422 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
5425 static Azure::Response<DirectoryListHandlesResult> ListHandles(
5426 const Azure::Core::Url& url,
5427 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5428 Azure::Core::Context context,
5429 const ListHandlesOptions& listHandlesOptions)
5431 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
5432 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"listhandles");
5433 if (listHandlesOptions.ContinuationToken.HasValue())
5435 request.GetUrl().AppendQueryParameter(
5436 _detail::QueryContinuationToken,
5437 _internal::UrlEncodeQueryParameter(listHandlesOptions.ContinuationToken.Value()));
5439 if (listHandlesOptions.MaxResults.HasValue())
5441 request.GetUrl().AppendQueryParameter(
5442 _detail::QueryPageSizeHint,
5443 _internal::UrlEncodeQueryParameter(
5444 std::to_string(listHandlesOptions.MaxResults.Value())));
5446 if (listHandlesOptions.Timeout.HasValue())
5448 request.GetUrl().AppendQueryParameter(
5449 _detail::QueryTimeout,
5450 _internal::UrlEncodeQueryParameter(
5451 std::to_string(listHandlesOptions.Timeout.Value())));
5453 if (listHandlesOptions.ShareSnapshot.HasValue())
5455 request.GetUrl().AppendQueryParameter(
5456 _detail::QueryShareSnapshot,
5457 _internal::UrlEncodeQueryParameter(listHandlesOptions.ShareSnapshot.Value()));
5459 if (listHandlesOptions.Recursive.HasValue())
5462 _detail::HeaderRecursive,
5463 (listHandlesOptions.Recursive.Value() ?
"true" :
"false"));
5465 request.SetHeader(_detail::HeaderVersion, listHandlesOptions.ApiVersionParameter);
5466 return ListHandlesParseResult(context, pipeline.Send(request, context));
5469 struct ForceCloseHandlesOptions final
5471 Azure::Nullable<int32_t> Timeout;
5472 Azure::Nullable<std::string> ContinuationToken;
5473 Azure::Nullable<std::string> ShareSnapshot;
5474 std::string HandleId;
5475 Azure::Nullable<bool> Recursive;
5476 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
5479 static Azure::Response<DirectoryForceCloseHandlesResult> ForceCloseHandles(
5480 const Azure::Core::Url& url,
5481 Azure::Core::Http::_internal::HttpPipeline& pipeline,
5482 Azure::Core::Context context,
5483 const ForceCloseHandlesOptions& forceCloseHandlesOptions)
5485 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
5486 request.SetHeader(_detail::HeaderContentLength,
"0");
5487 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"forceclosehandles");
5488 if (forceCloseHandlesOptions.Timeout.HasValue())
5490 request.GetUrl().AppendQueryParameter(
5491 _detail::QueryTimeout,
5492 _internal::UrlEncodeQueryParameter(
5493 std::to_string(forceCloseHandlesOptions.Timeout.Value())));
5495 if (forceCloseHandlesOptions.ContinuationToken.HasValue())
5497 request.GetUrl().AppendQueryParameter(
5498 _detail::QueryContinuationToken,
5499 _internal::UrlEncodeQueryParameter(
5500 forceCloseHandlesOptions.ContinuationToken.Value()));
5502 if (forceCloseHandlesOptions.ShareSnapshot.HasValue())
5504 request.GetUrl().AppendQueryParameter(
5505 _detail::QueryShareSnapshot,
5506 _internal::UrlEncodeQueryParameter(forceCloseHandlesOptions.ShareSnapshot.Value()));
5508 request.SetHeader(_detail::HeaderHandleId, forceCloseHandlesOptions.HandleId);
5509 if (forceCloseHandlesOptions.Recursive.HasValue())
5512 _detail::HeaderRecursive,
5513 (forceCloseHandlesOptions.Recursive.Value() ?
"true" :
"false"));
5515 request.SetHeader(_detail::HeaderVersion, forceCloseHandlesOptions.ApiVersionParameter);
5516 return ForceCloseHandlesParseResult(context, pipeline.Send(request, context));
5520 static Azure::Response<Models::CreateDirectoryResult> CreateParseResult(
5521 Azure::Core::Context context,
5522 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
5524 auto& response = *responsePtr;
5525 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
5528 Models::CreateDirectoryResult result;
5529 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
5530 result.LastModified = DateTime::Parse(
5531 response.GetHeaders().at(_detail::HeaderLastModified),
5532 DateTime::DateFormat::Rfc1123);
5533 result.IsServerEncrypted
5534 = response.GetHeaders().at(_detail::HeaderRequestIsServerEncrypted) ==
"true";
5535 result.SmbProperties.PermissionKey
5536 = response.GetHeaders().at(_detail::HeaderFilePermissionKey);
5537 result.SmbProperties.Attributes
5538 = FileAttributes(response.GetHeaders().at(_detail::HeaderAttributes));
5539 result.SmbProperties.CreatedOn = DateTime::Parse(
5540 response.GetHeaders().at(_detail::HeaderCreatedOn), DateTime::DateFormat::Rfc3339);
5541 result.SmbProperties.LastWrittenOn = DateTime::Parse(
5542 response.GetHeaders().at(_detail::HeaderLastWrittenOn),
5543 DateTime::DateFormat::Rfc3339);
5544 result.SmbProperties.ChangedOn = DateTime::Parse(
5545 response.GetHeaders().at(_detail::HeaderChangedOn), DateTime::DateFormat::Rfc3339);
5546 result.SmbProperties.FileId = response.GetHeaders().at(_detail::HeaderFileId);
5547 result.SmbProperties.ParentFileId
5548 = response.GetHeaders().at(_detail::HeaderParentFileId);
5549 return Azure::Response<Models::CreateDirectoryResult>(
5550 std::move(result), std::move(responsePtr));
5555 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
5559 static Azure::Response<Models::DirectoryProperties> GetPropertiesParseResult(
5560 Azure::Core::Context context,
5561 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
5563 auto& response = *responsePtr;
5564 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
5567 Models::DirectoryProperties result;
5569 for (
auto i = response.GetHeaders().lower_bound(_detail::HeaderMetadata);
5570 i != response.GetHeaders().end()
5571 && i->first.substr(0, 9) == _detail::HeaderMetadata;
5574 result.Metadata.emplace(i->first.substr(10), i->second);
5576 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
5577 result.LastModified = DateTime::Parse(
5578 response.GetHeaders().at(_detail::HeaderLastModified),
5579 DateTime::DateFormat::Rfc1123);
5580 result.IsServerEncrypted
5581 = response.GetHeaders().at(_detail::HeaderIsServerEncrypted) ==
"true";
5582 result.SmbProperties.Attributes
5583 = FileAttributes(response.GetHeaders().at(_detail::HeaderAttributes));
5584 result.SmbProperties.CreatedOn = DateTime::Parse(
5585 response.GetHeaders().at(_detail::HeaderCreatedOn), DateTime::DateFormat::Rfc3339);
5586 result.SmbProperties.LastWrittenOn = DateTime::Parse(
5587 response.GetHeaders().at(_detail::HeaderLastWrittenOn),
5588 DateTime::DateFormat::Rfc3339);
5589 result.SmbProperties.ChangedOn = DateTime::Parse(
5590 response.GetHeaders().at(_detail::HeaderChangedOn), DateTime::DateFormat::Rfc3339);
5591 result.SmbProperties.PermissionKey
5592 = response.GetHeaders().at(_detail::HeaderFilePermissionKey);
5593 result.SmbProperties.FileId = response.GetHeaders().at(_detail::HeaderFileId);
5594 result.SmbProperties.ParentFileId
5595 = response.GetHeaders().at(_detail::HeaderParentFileId);
5596 return Azure::Response<Models::DirectoryProperties>(
5597 std::move(result), std::move(responsePtr));
5602 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
5606 static Azure::Response<Models::DeleteDirectoryResult> DeleteParseResult(
5607 Azure::Core::Context context,
5608 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
5610 auto& response = *responsePtr;
5611 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)
5614 Models::DeleteDirectoryResult result;
5615 return Azure::Response<Models::DeleteDirectoryResult>(
5616 std::move(result), std::move(responsePtr));
5621 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
5625 static Azure::Response<Models::SetDirectoryPropertiesResult> SetPropertiesParseResult(
5626 Azure::Core::Context context,
5627 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
5629 auto& response = *responsePtr;
5630 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
5633 Models::SetDirectoryPropertiesResult result;
5634 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
5635 result.LastModified = DateTime::Parse(
5636 response.GetHeaders().at(_detail::HeaderLastModified),
5637 DateTime::DateFormat::Rfc1123);
5638 result.IsServerEncrypted
5639 = response.GetHeaders().at(_detail::HeaderRequestIsServerEncrypted) ==
"true";
5640 result.SmbProperties.PermissionKey
5641 = response.GetHeaders().at(_detail::HeaderFilePermissionKey);
5642 result.SmbProperties.Attributes
5643 = FileAttributes(response.GetHeaders().at(_detail::HeaderAttributes));
5644 result.SmbProperties.CreatedOn = DateTime::Parse(
5645 response.GetHeaders().at(_detail::HeaderCreatedOn), DateTime::DateFormat::Rfc3339);
5646 result.SmbProperties.LastWrittenOn = DateTime::Parse(
5647 response.GetHeaders().at(_detail::HeaderLastWrittenOn),
5648 DateTime::DateFormat::Rfc3339);
5649 result.SmbProperties.ChangedOn = DateTime::Parse(
5650 response.GetHeaders().at(_detail::HeaderChangedOn), DateTime::DateFormat::Rfc3339);
5651 result.SmbProperties.FileId = response.GetHeaders().at(_detail::HeaderFileId);
5652 result.SmbProperties.ParentFileId
5653 = response.GetHeaders().at(_detail::HeaderParentFileId);
5654 return Azure::Response<Models::SetDirectoryPropertiesResult>(
5655 std::move(result), std::move(responsePtr));
5660 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
5664 static Azure::Response<Models::SetDirectoryMetadataResult> SetMetadataParseResult(
5665 Azure::Core::Context context,
5666 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
5668 auto& response = *responsePtr;
5669 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
5672 Models::SetDirectoryMetadataResult result;
5673 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
5674 result.IsServerEncrypted
5675 = response.GetHeaders().at(_detail::HeaderRequestIsServerEncrypted) ==
"true";
5676 return Azure::Response<Models::SetDirectoryMetadataResult>(
5677 std::move(result), std::move(responsePtr));
5682 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
5686 static Azure::Response<DirectoryListFilesAndDirectoriesSinglePageResult>
5687 ListFilesAndDirectoriesSinglePageParseResult(
5688 Azure::Core::Context context,
5689 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
5691 auto& response = *responsePtr;
5692 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
5695 const auto& bodyBuffer = response.GetBody();
5696 auto reader = _internal::XmlReader(
5697 reinterpret_cast<const char*
>(bodyBuffer.data()), bodyBuffer.size());
5698 DirectoryListFilesAndDirectoriesSinglePageResult result = bodyBuffer.empty()
5699 ? DirectoryListFilesAndDirectoriesSinglePageResult()
5700 : DirectoryListFilesAndDirectoriesSinglePageResultFromListFilesAndDirectoriesSinglePageResponse(
5701 ListFilesAndDirectoriesSinglePageResponseFromXml(reader));
5702 result.HttpHeaders.ContentType = response.GetHeaders().at(_detail::HeaderContentType);
5703 return Azure::Response<DirectoryListFilesAndDirectoriesSinglePageResult>(
5704 std::move(result), std::move(responsePtr));
5709 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
5713 static DirectoryItem DirectoryItemFromXml(_internal::XmlReader& reader)
5715 auto result = DirectoryItem();
5716 enum class XmlTagName
5721 std::vector<XmlTagName> path;
5725 auto node = reader.Read();
5726 if (node.Type == _internal::XmlNodeType::End)
5730 else if (node.Type == _internal::XmlNodeType::EndTag)
5732 if (path.size() > 0)
5741 else if (node.Type == _internal::XmlNodeType::StartTag)
5744 if (std::strcmp(node.Name,
"Name") == 0)
5746 path.emplace_back(XmlTagName::Name);
5750 path.emplace_back(XmlTagName::Unknown);
5753 else if (node.Type == _internal::XmlNodeType::Text)
5755 if (path.size() == 1 && path[0] == XmlTagName::Name)
5757 result.Name = node.Value;
5764 static FileItemDetails FileItemDetailsFromXml(_internal::XmlReader& reader)
5766 auto result = FileItemDetails();
5767 enum class XmlTagName
5772 std::vector<XmlTagName> path;
5776 auto node = reader.Read();
5777 if (node.Type == _internal::XmlNodeType::End)
5781 else if (node.Type == _internal::XmlNodeType::EndTag)
5783 if (path.size() > 0)
5792 else if (node.Type == _internal::XmlNodeType::StartTag)
5795 if (std::strcmp(node.Name,
"Content-Length") == 0)
5797 path.emplace_back(XmlTagName::ContentLength);
5801 path.emplace_back(XmlTagName::Unknown);
5804 else if (node.Type == _internal::XmlNodeType::Text)
5806 if (path.size() == 1 && path[0] == XmlTagName::ContentLength)
5808 result.FileSize = std::stoll(node.Value);
5815 static FileItem FileItemFromXml(_internal::XmlReader& reader)
5817 auto result = FileItem();
5818 enum class XmlTagName
5824 std::vector<XmlTagName> path;
5828 auto node = reader.Read();
5829 if (node.Type == _internal::XmlNodeType::End)
5833 else if (node.Type == _internal::XmlNodeType::EndTag)
5835 if (path.size() > 0)
5844 else if (node.Type == _internal::XmlNodeType::StartTag)
5847 if (std::strcmp(node.Name,
"Name") == 0)
5849 path.emplace_back(XmlTagName::Name);
5851 else if (std::strcmp(node.Name,
"Properties") == 0)
5853 path.emplace_back(XmlTagName::Properties);
5857 path.emplace_back(XmlTagName::Unknown);
5860 if (path.size() == 1 && path[0] == XmlTagName::Properties)
5862 result.Details = FileItemDetailsFromXml(reader);
5866 else if (node.Type == _internal::XmlNodeType::Text)
5868 if (path.size() == 1 && path[0] == XmlTagName::Name)
5870 result.Name = node.Value;
5877 static FilesAndDirectoriesListSinglePage FilesAndDirectoriesListSinglePageFromXml(
5878 _internal::XmlReader& reader)
5880 auto result = FilesAndDirectoriesListSinglePage();
5881 enum class XmlTagName
5887 std::vector<XmlTagName> path;
5891 auto node = reader.Read();
5892 if (node.Type == _internal::XmlNodeType::End)
5896 else if (node.Type == _internal::XmlNodeType::EndTag)
5898 if (path.size() > 0)
5907 else if (node.Type == _internal::XmlNodeType::StartTag)
5910 if (std::strcmp(node.Name,
"Directory") == 0)
5912 path.emplace_back(XmlTagName::Directory);
5914 else if (std::strcmp(node.Name,
"File") == 0)
5916 path.emplace_back(XmlTagName::File);
5920 path.emplace_back(XmlTagName::Unknown);
5922 if (path.size() == 1 && path[0] == XmlTagName::Directory)
5924 result.DirectoryItems.emplace_back(DirectoryItemFromXml(reader));
5927 else if (path.size() == 1 && path[0] == XmlTagName::File)
5929 result.FileItems.emplace_back(FileItemFromXml(reader));
5933 else if (node.Type == _internal::XmlNodeType::Text)
5940 static ListFilesAndDirectoriesSinglePageResponse
5941 ListFilesAndDirectoriesSinglePageResponseFromXml(_internal::XmlReader& reader)
5943 auto result = ListFilesAndDirectoriesSinglePageResponse();
5944 enum class XmlTagName
5953 std::vector<XmlTagName> path;
5957 auto node = reader.Read();
5958 if (node.Type == _internal::XmlNodeType::End)
5962 else if (node.Type == _internal::XmlNodeType::EndTag)
5964 if (path.size() > 0)
5973 else if (node.Type == _internal::XmlNodeType::StartTag)
5976 if (std::strcmp(node.Name,
"Entries") == 0)
5978 path.emplace_back(XmlTagName::Entries);
5980 else if (std::strcmp(node.Name,
"EnumerationResults") == 0)
5982 path.emplace_back(XmlTagName::EnumerationResults);
5984 else if (std::strcmp(node.Name,
"MaxResults") == 0)
5986 path.emplace_back(XmlTagName::MaxResults);
5988 else if (std::strcmp(node.Name,
"NextMarker") == 0)
5990 path.emplace_back(XmlTagName::NextMarker);
5992 else if (std::strcmp(node.Name,
"Prefix") == 0)
5994 path.emplace_back(XmlTagName::Prefix);
5998 path.emplace_back(XmlTagName::Unknown);
6001 if (path.size() == 2 && path[0] == XmlTagName::EnumerationResults
6002 && path[1] == XmlTagName::Entries)
6004 result.SinglePage = FilesAndDirectoriesListSinglePageFromXml(reader);
6008 else if (node.Type == _internal::XmlNodeType::Text)
6010 if (path.size() == 2 && path[0] == XmlTagName::EnumerationResults
6011 && path[1] == XmlTagName::NextMarker)
6013 result.ContinuationToken = node.Value;
6016 path.size() == 2 && path[0] == XmlTagName::EnumerationResults
6017 && path[1] == XmlTagName::MaxResults)
6019 result.PageSizeHint = std::stoi(node.Value);
6022 path.size() == 2 && path[0] == XmlTagName::EnumerationResults
6023 && path[1] == XmlTagName::Prefix)
6025 result.Prefix = node.Value;
6028 else if (node.Type == _internal::XmlNodeType::Attribute)
6030 if (path.size() == 1 && path[0] == XmlTagName::EnumerationResults
6031 && (std::strcmp(node.Name,
"DirectoryPath") == 0))
6033 result.DirectoryPath = node.Value;
6036 path.size() == 1 && path[0] == XmlTagName::EnumerationResults
6037 && (std::strcmp(node.Name,
"ServiceEndpoint") == 0))
6039 result.ServiceEndpoint = node.Value;
6042 path.size() == 1 && path[0] == XmlTagName::EnumerationResults
6043 && (std::strcmp(node.Name,
"ShareName") == 0))
6045 result.ShareName = node.Value;
6048 path.size() == 1 && path[0] == XmlTagName::EnumerationResults
6049 && (std::strcmp(node.Name,
"ShareSnapshot") == 0))
6051 result.ShareSnapshot = node.Value;
6058 static DirectoryListFilesAndDirectoriesSinglePageResult
6059 DirectoryListFilesAndDirectoriesSinglePageResultFromListFilesAndDirectoriesSinglePageResponse(
6060 ListFilesAndDirectoriesSinglePageResponse
object)
6062 DirectoryListFilesAndDirectoriesSinglePageResult result;
6063 result.ServiceEndpoint = std::move(
object.ServiceEndpoint);
6064 result.ShareName = std::move(
object.ShareName);
6065 result.ShareSnapshot = std::move(
object.ShareSnapshot);
6066 result.DirectoryPath = std::move(
object.DirectoryPath);
6067 result.Prefix = std::move(
object.Prefix);
6068 result.PageSizeHint =
object.PageSizeHint;
6069 result.SinglePage = std::move(
object.SinglePage);
6070 result.ContinuationToken = std::move(
object.ContinuationToken);
6074 static Azure::Response<DirectoryListHandlesResult> ListHandlesParseResult(
6075 Azure::Core::Context context,
6076 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
6078 auto& response = *responsePtr;
6079 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
6082 const auto& bodyBuffer = response.GetBody();
6083 auto reader = _internal::XmlReader(
6084 reinterpret_cast<const char*
>(bodyBuffer.data()), bodyBuffer.size());
6085 DirectoryListHandlesResult result = bodyBuffer.empty()
6086 ? DirectoryListHandlesResult()
6087 : DirectoryListHandlesResultFromListHandlesResponse(
6088 ListHandlesResponseFromXml(reader));
6089 result.HttpHeaders.ContentType = response.GetHeaders().at(_detail::HeaderContentType);
6090 return Azure::Response<DirectoryListHandlesResult>(
6091 std::move(result), std::move(responsePtr));
6096 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
6100 static HandleItem HandleItemFromXml(_internal::XmlReader& reader)
6102 auto result = HandleItem();
6103 enum class XmlTagName
6115 std::vector<XmlTagName> path;
6119 auto node = reader.Read();
6120 if (node.Type == _internal::XmlNodeType::End)
6124 else if (node.Type == _internal::XmlNodeType::EndTag)
6126 if (path.size() > 0)
6135 else if (node.Type == _internal::XmlNodeType::StartTag)
6138 if (std::strcmp(node.Name,
"ClientIp") == 0)
6140 path.emplace_back(XmlTagName::ClientIp);
6142 else if (std::strcmp(node.Name,
"FileId") == 0)
6144 path.emplace_back(XmlTagName::FileId);
6146 else if (std::strcmp(node.Name,
"HandleId") == 0)
6148 path.emplace_back(XmlTagName::HandleId);
6150 else if (std::strcmp(node.Name,
"LastReconnectTime") == 0)
6152 path.emplace_back(XmlTagName::LastReconnectTime);
6154 else if (std::strcmp(node.Name,
"OpenTime") == 0)
6156 path.emplace_back(XmlTagName::OpenTime);
6158 else if (std::strcmp(node.Name,
"ParentId") == 0)
6160 path.emplace_back(XmlTagName::ParentId);
6162 else if (std::strcmp(node.Name,
"Path") == 0)
6164 path.emplace_back(XmlTagName::Path);
6166 else if (std::strcmp(node.Name,
"SessionId") == 0)
6168 path.emplace_back(XmlTagName::SessionId);
6172 path.emplace_back(XmlTagName::Unknown);
6175 else if (node.Type == _internal::XmlNodeType::Text)
6177 if (path.size() == 1 && path[0] == XmlTagName::ClientIp)
6179 result.ClientIp = node.Value;
6181 else if (path.size() == 1 && path[0] == XmlTagName::FileId)
6183 result.FileId = node.Value;
6185 else if (path.size() == 1 && path[0] == XmlTagName::HandleId)
6187 result.HandleId = node.Value;
6189 else if (path.size() == 1 && path[0] == XmlTagName::LastReconnectTime)
6191 result.LastReconnectedOn
6192 = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc1123);
6194 else if (path.size() == 1 && path[0] == XmlTagName::OpenTime)
6196 result.OpenedOn = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc1123);
6198 else if (path.size() == 1 && path[0] == XmlTagName::ParentId)
6200 result.ParentId = node.Value;
6202 else if (path.size() == 1 && path[0] == XmlTagName::Path)
6204 result.Path = node.Value;
6206 else if (path.size() == 1 && path[0] == XmlTagName::SessionId)
6208 result.SessionId = node.Value;
6215 static ListHandlesResponse ListHandlesResponseFromXml(_internal::XmlReader& reader)
6217 auto result = ListHandlesResponse();
6218 enum class XmlTagName
6226 std::vector<XmlTagName> path;
6230 auto node = reader.Read();
6231 if (node.Type == _internal::XmlNodeType::End)
6235 else if (node.Type == _internal::XmlNodeType::EndTag)
6237 if (path.size() > 0)
6246 else if (node.Type == _internal::XmlNodeType::StartTag)
6249 if (std::strcmp(node.Name,
"Entries") == 0)
6251 path.emplace_back(XmlTagName::Entries);
6253 else if (std::strcmp(node.Name,
"EnumerationResults") == 0)
6255 path.emplace_back(XmlTagName::EnumerationResults);
6257 else if (std::strcmp(node.Name,
"Handle") == 0)
6259 path.emplace_back(XmlTagName::Handle);
6261 else if (std::strcmp(node.Name,
"NextMarker") == 0)
6263 path.emplace_back(XmlTagName::NextMarker);
6267 path.emplace_back(XmlTagName::Unknown);
6269 if (path.size() == 3 && path[0] == XmlTagName::EnumerationResults
6270 && path[1] == XmlTagName::Entries && path[2] == XmlTagName::Handle)
6272 result.HandleList.emplace_back(HandleItemFromXml(reader));
6276 else if (node.Type == _internal::XmlNodeType::Text)
6278 if (path.size() == 2 && path[0] == XmlTagName::EnumerationResults
6279 && path[1] == XmlTagName::NextMarker)
6281 result.ContinuationToken = node.Value;
6288 static DirectoryListHandlesResult DirectoryListHandlesResultFromListHandlesResponse(
6289 ListHandlesResponse
object)
6291 DirectoryListHandlesResult result;
6292 result.HandleList = std::move(
object.HandleList);
6293 result.ContinuationToken = std::move(
object.ContinuationToken);
6297 static Azure::Response<DirectoryForceCloseHandlesResult> ForceCloseHandlesParseResult(
6298 Azure::Core::Context context,
6299 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
6301 auto& response = *responsePtr;
6302 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
6305 DirectoryForceCloseHandlesResult result;
6306 if (response.GetHeaders().find(_detail::HeaderContinuationToken)
6307 != response.GetHeaders().end())
6309 result.ContinuationToken = response.GetHeaders().at(_detail::HeaderContinuationToken);
6311 result.NumberOfHandlesClosed
6312 = std::stoi(response.GetHeaders().at(_detail::HeaderNumberOfHandlesClosed));
6313 result.NumberOfHandlesFailedToClose
6314 = std::stoi(response.GetHeaders().at(_detail::HeaderNumberOfHandlesFailedToClose));
6315 return Azure::Response<DirectoryForceCloseHandlesResult>(
6316 std::move(result), std::move(responsePtr));
6321 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
6328 struct CreateOptions final
6330 Azure::Nullable<int32_t> Timeout;
6331 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6332 int64_t XMsContentLength = int64_t();
6333 Azure::Nullable<std::string> FileContentType;
6334 Azure::Nullable<std::string> FileContentEncoding;
6335 Azure::Nullable<std::string> FileContentLanguage;
6336 Azure::Nullable<std::string> FileCacheControl;
6337 Azure::Nullable<Storage::ContentHash> ContentMd5;
6338 Azure::Nullable<std::string> FileContentDisposition;
6339 Storage::Metadata Metadata;
6340 Azure::Nullable<std::string> FilePermission;
6341 Azure::Nullable<std::string> FilePermissionKey;
6342 std::string FileAttributes;
6343 std::string FileCreationTime;
6344 std::string FileLastWriteTime;
6345 Azure::Nullable<std::string> LeaseIdOptional;
6348 static Azure::Response<Models::CreateFileResult> Create(
6349 const Azure::Core::Url& url,
6350 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6351 Azure::Core::Context context,
6352 const CreateOptions& createOptions)
6354 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
6355 request.SetHeader(_detail::HeaderContentLength,
"0");
6356 if (createOptions.Timeout.HasValue())
6358 request.GetUrl().AppendQueryParameter(
6359 _detail::QueryTimeout,
6360 _internal::UrlEncodeQueryParameter(std::to_string(createOptions.Timeout.Value())));
6362 request.SetHeader(_detail::HeaderVersion, createOptions.ApiVersionParameter);
6364 _detail::HeaderXMsContentLength, std::to_string(createOptions.XMsContentLength));
6365 request.SetHeader(_detail::HeaderFileTypeConstant,
"file");
6366 if (createOptions.FileContentType.HasValue())
6369 _detail::HeaderFileContentType, createOptions.FileContentType.Value());
6371 if (createOptions.FileContentEncoding.HasValue())
6374 _detail::HeaderFileContentEncoding, createOptions.FileContentEncoding.Value());
6376 if (createOptions.FileContentLanguage.HasValue())
6379 _detail::HeaderFileContentLanguage, createOptions.FileContentLanguage.Value());
6381 if (createOptions.FileCacheControl.HasValue())
6384 _detail::HeaderFileCacheControl, createOptions.FileCacheControl.Value());
6386 if (createOptions.ContentMd5.HasValue())
6389 _detail::HeaderContentHashMd5,
6390 _internal::ToBase64String(createOptions.ContentMd5.Value()));
6392 if (createOptions.FileContentDisposition.HasValue())
6395 _detail::HeaderFileContentDisposition,
6396 createOptions.FileContentDisposition.Value());
6398 for (
const auto& pair : createOptions.Metadata)
6400 request.SetHeader(_detail::HeaderMetadata + (
"-" + pair.first), pair.second);
6402 if (createOptions.FilePermission.HasValue())
6404 request.SetHeader(_detail::HeaderFilePermission, createOptions.FilePermission.Value());
6406 if (createOptions.FilePermissionKey.HasValue())
6409 _detail::HeaderFilePermissionKey, createOptions.FilePermissionKey.Value());
6411 request.SetHeader(_detail::HeaderFileAttributes, createOptions.FileAttributes);
6412 request.SetHeader(_detail::HeaderFileCreatedOn, createOptions.FileCreationTime);
6413 request.SetHeader(_detail::HeaderFileLastWrittenOn, createOptions.FileLastWriteTime);
6414 if (createOptions.LeaseIdOptional.HasValue())
6416 request.SetHeader(_detail::HeaderLeaseId, createOptions.LeaseIdOptional.Value());
6418 return CreateParseResult(context, pipeline.Send(request, context));
6421 struct DownloadOptions final
6423 Azure::Nullable<int32_t> Timeout;
6424 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6425 Azure::Nullable<std::string> Range;
6426 Azure::Nullable<bool> GetRangeContentMd5;
6427 Azure::Nullable<std::string> LeaseIdOptional;
6430 static Azure::Response<FileDownloadResult> Download(
6431 const Azure::Core::Url& url,
6432 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6433 Azure::Core::Context context,
6434 const DownloadOptions& downloadOptions)
6436 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url,
false);
6437 if (downloadOptions.Timeout.HasValue())
6439 request.GetUrl().AppendQueryParameter(
6440 _detail::QueryTimeout,
6441 _internal::UrlEncodeQueryParameter(
6442 std::to_string(downloadOptions.Timeout.Value())));
6444 request.SetHeader(_detail::HeaderVersion, downloadOptions.ApiVersionParameter);
6445 if (downloadOptions.Range.HasValue())
6447 request.SetHeader(_detail::HeaderRange, downloadOptions.Range.Value());
6449 if (downloadOptions.GetRangeContentMd5.HasValue())
6452 _detail::HeaderRangeGetContentMd5,
6453 (downloadOptions.GetRangeContentMd5.Value() ?
"true" :
"false"));
6455 if (downloadOptions.LeaseIdOptional.HasValue())
6457 request.SetHeader(_detail::HeaderLeaseId, downloadOptions.LeaseIdOptional.Value());
6459 return DownloadParseResult(context, pipeline.Send(request, context));
6462 struct GetPropertiesOptions final
6464 Azure::Nullable<std::string> ShareSnapshot;
6465 Azure::Nullable<int32_t> Timeout;
6466 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6467 Azure::Nullable<std::string> LeaseIdOptional;
6470 static Azure::Response<Models::FileProperties> GetProperties(
6471 const Azure::Core::Url& url,
6472 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6473 Azure::Core::Context context,
6474 const GetPropertiesOptions& getPropertiesOptions)
6476 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Head, url);
6477 if (getPropertiesOptions.ShareSnapshot.HasValue())
6479 request.GetUrl().AppendQueryParameter(
6480 _detail::QueryShareSnapshot,
6481 _internal::UrlEncodeQueryParameter(getPropertiesOptions.ShareSnapshot.Value()));
6483 if (getPropertiesOptions.Timeout.HasValue())
6485 request.GetUrl().AppendQueryParameter(
6486 _detail::QueryTimeout,
6487 _internal::UrlEncodeQueryParameter(
6488 std::to_string(getPropertiesOptions.Timeout.Value())));
6490 request.SetHeader(_detail::HeaderVersion, getPropertiesOptions.ApiVersionParameter);
6491 if (getPropertiesOptions.LeaseIdOptional.HasValue())
6493 request.SetHeader(_detail::HeaderLeaseId, getPropertiesOptions.LeaseIdOptional.Value());
6495 return GetPropertiesParseResult(context, pipeline.Send(request, context));
6498 struct DeleteOptions final
6500 Azure::Nullable<int32_t> Timeout;
6501 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6502 Azure::Nullable<std::string> LeaseIdOptional;
6505 static Azure::Response<Models::DeleteFileResult> Delete(
6506 const Azure::Core::Url& url,
6507 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6508 Azure::Core::Context context,
6509 const DeleteOptions& deleteOptions)
6511 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Delete, url);
6512 if (deleteOptions.Timeout.HasValue())
6514 request.GetUrl().AppendQueryParameter(
6515 _detail::QueryTimeout,
6516 _internal::UrlEncodeQueryParameter(std::to_string(deleteOptions.Timeout.Value())));
6518 request.SetHeader(_detail::HeaderVersion, deleteOptions.ApiVersionParameter);
6519 if (deleteOptions.LeaseIdOptional.HasValue())
6521 request.SetHeader(_detail::HeaderLeaseId, deleteOptions.LeaseIdOptional.Value());
6523 return DeleteParseResult(context, pipeline.Send(request, context));
6526 struct SetHttpHeadersOptions final
6528 Azure::Nullable<int32_t> Timeout;
6529 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6530 Azure::Nullable<int64_t> XMsContentLength;
6531 Azure::Nullable<std::string> FileContentType;
6532 Azure::Nullable<std::string> FileContentEncoding;
6533 Azure::Nullable<std::string> FileContentLanguage;
6534 Azure::Nullable<std::string> FileCacheControl;
6535 Azure::Nullable<Storage::ContentHash> ContentMd5;
6536 Azure::Nullable<std::string> FileContentDisposition;
6537 Azure::Nullable<std::string> FilePermission;
6538 Azure::Nullable<std::string> FilePermissionKey;
6539 std::string FileAttributes;
6540 std::string FileCreationTime;
6541 std::string FileLastWriteTime;
6542 Azure::Nullable<std::string> LeaseIdOptional;
6545 static Azure::Response<Models::SetFilePropertiesResult> SetHttpHeaders(
6546 const Azure::Core::Url& url,
6547 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6548 Azure::Core::Context context,
6549 const SetHttpHeadersOptions& setHttpHeadersOptions)
6551 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
6552 request.SetHeader(_detail::HeaderContentLength,
"0");
6553 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"properties");
6554 if (setHttpHeadersOptions.Timeout.HasValue())
6556 request.GetUrl().AppendQueryParameter(
6557 _detail::QueryTimeout,
6558 _internal::UrlEncodeQueryParameter(
6559 std::to_string(setHttpHeadersOptions.Timeout.Value())));
6561 request.SetHeader(_detail::HeaderVersion, setHttpHeadersOptions.ApiVersionParameter);
6562 if (setHttpHeadersOptions.XMsContentLength.HasValue())
6565 _detail::HeaderXMsContentLength,
6566 std::to_string(setHttpHeadersOptions.XMsContentLength.Value()));
6568 if (setHttpHeadersOptions.FileContentType.HasValue())
6571 _detail::HeaderFileContentType, setHttpHeadersOptions.FileContentType.Value());
6573 if (setHttpHeadersOptions.FileContentEncoding.HasValue())
6576 _detail::HeaderFileContentEncoding,
6577 setHttpHeadersOptions.FileContentEncoding.Value());
6579 if (setHttpHeadersOptions.FileContentLanguage.HasValue())
6582 _detail::HeaderFileContentLanguage,
6583 setHttpHeadersOptions.FileContentLanguage.Value());
6585 if (setHttpHeadersOptions.FileCacheControl.HasValue())
6588 _detail::HeaderFileCacheControl, setHttpHeadersOptions.FileCacheControl.Value());
6590 if (setHttpHeadersOptions.ContentMd5.HasValue())
6593 _detail::HeaderContentHashMd5,
6594 _internal::ToBase64String(setHttpHeadersOptions.ContentMd5.Value()));
6596 if (setHttpHeadersOptions.FileContentDisposition.HasValue())
6599 _detail::HeaderFileContentDisposition,
6600 setHttpHeadersOptions.FileContentDisposition.Value());
6602 if (setHttpHeadersOptions.FilePermission.HasValue())
6605 _detail::HeaderFilePermission, setHttpHeadersOptions.FilePermission.Value());
6607 if (setHttpHeadersOptions.FilePermissionKey.HasValue())
6610 _detail::HeaderFilePermissionKey, setHttpHeadersOptions.FilePermissionKey.Value());
6612 request.SetHeader(_detail::HeaderFileAttributes, setHttpHeadersOptions.FileAttributes);
6613 request.SetHeader(_detail::HeaderFileCreatedOn, setHttpHeadersOptions.FileCreationTime);
6615 _detail::HeaderFileLastWrittenOn, setHttpHeadersOptions.FileLastWriteTime);
6616 if (setHttpHeadersOptions.LeaseIdOptional.HasValue())
6619 _detail::HeaderLeaseId, setHttpHeadersOptions.LeaseIdOptional.Value());
6621 return SetHttpHeadersParseResult(context, pipeline.Send(request, context));
6624 struct SetMetadataOptions final
6626 Azure::Nullable<int32_t> Timeout;
6627 Storage::Metadata Metadata;
6628 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6629 Azure::Nullable<std::string> LeaseIdOptional;
6632 static Azure::Response<Models::SetFileMetadataResult> SetMetadata(
6633 const Azure::Core::Url& url,
6634 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6635 Azure::Core::Context context,
6636 const SetMetadataOptions& setMetadataOptions)
6638 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
6639 request.SetHeader(_detail::HeaderContentLength,
"0");
6640 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"metadata");
6641 if (setMetadataOptions.Timeout.HasValue())
6643 request.GetUrl().AppendQueryParameter(
6644 _detail::QueryTimeout,
6645 _internal::UrlEncodeQueryParameter(
6646 std::to_string(setMetadataOptions.Timeout.Value())));
6648 for (
const auto& pair : setMetadataOptions.Metadata)
6650 request.SetHeader(_detail::HeaderMetadata + (
"-" + pair.first), pair.second);
6652 request.SetHeader(_detail::HeaderVersion, setMetadataOptions.ApiVersionParameter);
6653 if (setMetadataOptions.LeaseIdOptional.HasValue())
6655 request.SetHeader(_detail::HeaderLeaseId, setMetadataOptions.LeaseIdOptional.Value());
6657 return SetMetadataParseResult(context, pipeline.Send(request, context));
6660 struct AcquireLeaseOptions final
6662 Azure::Nullable<int32_t> Timeout;
6663 int32_t LeaseDuration = int32_t();
6664 Azure::Nullable<std::string> ProposedLeaseIdOptional;
6665 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6668 static Azure::Response<FileAcquireLeaseResult> AcquireLease(
6669 const Azure::Core::Url& url,
6670 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6671 Azure::Core::Context context,
6672 const AcquireLeaseOptions& acquireLeaseOptions)
6674 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
6675 request.SetHeader(_detail::HeaderContentLength,
"0");
6676 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"lease");
6677 request.SetHeader(_detail::HeaderAction,
"acquire");
6678 if (acquireLeaseOptions.Timeout.HasValue())
6680 request.GetUrl().AppendQueryParameter(
6681 _detail::QueryTimeout,
6682 _internal::UrlEncodeQueryParameter(
6683 std::to_string(acquireLeaseOptions.Timeout.Value())));
6686 _detail::HeaderDuration, std::to_string(acquireLeaseOptions.LeaseDuration));
6687 if (acquireLeaseOptions.ProposedLeaseIdOptional.HasValue())
6690 _detail::HeaderProposedLeaseId,
6691 acquireLeaseOptions.ProposedLeaseIdOptional.Value());
6693 request.SetHeader(_detail::HeaderVersion, acquireLeaseOptions.ApiVersionParameter);
6694 return AcquireLeaseParseResult(context, pipeline.Send(request, context));
6697 struct ReleaseLeaseOptions final
6699 Azure::Nullable<int32_t> Timeout;
6700 std::string LeaseIdRequired;
6701 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6704 static Azure::Response<FileReleaseLeaseResult> ReleaseLease(
6705 const Azure::Core::Url& url,
6706 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6707 Azure::Core::Context context,
6708 const ReleaseLeaseOptions& releaseLeaseOptions)
6710 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
6711 request.SetHeader(_detail::HeaderContentLength,
"0");
6712 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"lease");
6713 request.SetHeader(_detail::HeaderAction,
"release");
6714 if (releaseLeaseOptions.Timeout.HasValue())
6716 request.GetUrl().AppendQueryParameter(
6717 _detail::QueryTimeout,
6718 _internal::UrlEncodeQueryParameter(
6719 std::to_string(releaseLeaseOptions.Timeout.Value())));
6721 request.SetHeader(_detail::HeaderLeaseId, releaseLeaseOptions.LeaseIdRequired);
6722 request.SetHeader(_detail::HeaderVersion, releaseLeaseOptions.ApiVersionParameter);
6723 return ReleaseLeaseParseResult(context, pipeline.Send(request, context));
6726 struct ChangeLeaseOptions final
6728 Azure::Nullable<int32_t> Timeout;
6729 std::string LeaseIdRequired;
6730 Azure::Nullable<std::string> ProposedLeaseIdOptional;
6731 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6734 static Azure::Response<FileChangeLeaseResult> ChangeLease(
6735 const Azure::Core::Url& url,
6736 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6737 Azure::Core::Context context,
6738 const ChangeLeaseOptions& changeLeaseOptions)
6740 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
6741 request.SetHeader(_detail::HeaderContentLength,
"0");
6742 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"lease");
6743 request.SetHeader(_detail::HeaderAction,
"change");
6744 if (changeLeaseOptions.Timeout.HasValue())
6746 request.GetUrl().AppendQueryParameter(
6747 _detail::QueryTimeout,
6748 _internal::UrlEncodeQueryParameter(
6749 std::to_string(changeLeaseOptions.Timeout.Value())));
6751 request.SetHeader(_detail::HeaderLeaseId, changeLeaseOptions.LeaseIdRequired);
6752 if (changeLeaseOptions.ProposedLeaseIdOptional.HasValue())
6755 _detail::HeaderProposedLeaseId, changeLeaseOptions.ProposedLeaseIdOptional.Value());
6757 request.SetHeader(_detail::HeaderVersion, changeLeaseOptions.ApiVersionParameter);
6758 return ChangeLeaseParseResult(context, pipeline.Send(request, context));
6761 struct BreakLeaseOptions final
6763 Azure::Nullable<int32_t> Timeout;
6764 Azure::Nullable<std::string> LeaseIdOptional;
6765 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6768 static Azure::Response<FileBreakLeaseResult> BreakLease(
6769 const Azure::Core::Url& url,
6770 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6771 Azure::Core::Context context,
6772 const BreakLeaseOptions& breakLeaseOptions)
6774 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
6775 request.SetHeader(_detail::HeaderContentLength,
"0");
6776 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"lease");
6777 request.SetHeader(_detail::HeaderAction,
"break");
6778 if (breakLeaseOptions.Timeout.HasValue())
6780 request.GetUrl().AppendQueryParameter(
6781 _detail::QueryTimeout,
6782 _internal::UrlEncodeQueryParameter(
6783 std::to_string(breakLeaseOptions.Timeout.Value())));
6785 if (breakLeaseOptions.LeaseIdOptional.HasValue())
6787 request.SetHeader(_detail::HeaderLeaseId, breakLeaseOptions.LeaseIdOptional.Value());
6789 request.SetHeader(_detail::HeaderVersion, breakLeaseOptions.ApiVersionParameter);
6790 return BreakLeaseParseResult(context, pipeline.Send(request, context));
6793 struct UploadRangeOptions final
6795 Azure::Nullable<int32_t> Timeout;
6796 std::string XMsRange;
6797 FileRangeWrite XMsWrite;
6798 int64_t ContentLength = int64_t();
6799 Azure::Nullable<Storage::ContentHash> ContentMd5;
6800 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6801 Azure::Nullable<std::string> LeaseIdOptional;
6804 static Azure::Response<Models::UploadFileRangeResult> UploadRange(
6805 const Azure::Core::Url& url,
6806 Azure::Core::IO::BodyStream& bodyStream,
6807 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6808 Azure::Core::Context context,
6809 const UploadRangeOptions& uploadRangeOptions)
6811 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url, &bodyStream);
6812 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"range");
6813 if (uploadRangeOptions.Timeout.HasValue())
6815 request.GetUrl().AppendQueryParameter(
6816 _detail::QueryTimeout,
6817 _internal::UrlEncodeQueryParameter(
6818 std::to_string(uploadRangeOptions.Timeout.Value())));
6820 request.SetHeader(_detail::HeaderXMsRange, uploadRangeOptions.XMsRange);
6821 request.SetHeader(_detail::HeaderFileRangeWrite, uploadRangeOptions.XMsWrite.ToString());
6823 _detail::HeaderContentLength, std::to_string(uploadRangeOptions.ContentLength));
6824 if (uploadRangeOptions.ContentMd5.HasValue())
6827 _detail::HeaderContentHashMd5,
6828 _internal::ToBase64String(uploadRangeOptions.ContentMd5.Value()));
6830 request.SetHeader(_detail::HeaderVersion, uploadRangeOptions.ApiVersionParameter);
6831 if (uploadRangeOptions.LeaseIdOptional.HasValue())
6833 request.SetHeader(_detail::HeaderLeaseId, uploadRangeOptions.LeaseIdOptional.Value());
6835 return UploadRangeParseResult(context, pipeline.Send(request, context));
6838 struct UploadRangeFromUrlOptions final
6840 Azure::Nullable<int32_t> Timeout;
6841 std::string TargetRange;
6842 std::string CopySource;
6843 Azure::Nullable<std::string> SourceRange;
6844 FileRangeWriteFromUrl XMsWrite;
6845 int64_t ContentLength = int64_t();
6846 Azure::Nullable<Storage::ContentHash> SourceContentCrc64;
6847 Azure::Nullable<Storage::ContentHash> SourceIfMatchCrc64;
6848 Azure::Nullable<Storage::ContentHash> SourceIfNoneMatchCrc64;
6849 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6850 Azure::Nullable<std::string> LeaseIdOptional;
6853 static Azure::Response<Models::UploadFileRangeFromUriResult> UploadRangeFromUrl(
6854 const Azure::Core::Url& url,
6855 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6856 Azure::Core::Context context,
6857 const UploadRangeFromUrlOptions& uploadRangeFromUrlOptions)
6859 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
6860 request.SetHeader(_detail::HeaderContentLength,
"0");
6861 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"range");
6862 if (uploadRangeFromUrlOptions.Timeout.HasValue())
6864 request.GetUrl().AppendQueryParameter(
6865 _detail::QueryTimeout,
6866 _internal::UrlEncodeQueryParameter(
6867 std::to_string(uploadRangeFromUrlOptions.Timeout.Value())));
6869 request.SetHeader(_detail::HeaderRange, uploadRangeFromUrlOptions.TargetRange);
6870 request.SetHeader(_detail::HeaderCopySource, uploadRangeFromUrlOptions.CopySource);
6871 if (uploadRangeFromUrlOptions.SourceRange.HasValue())
6874 _detail::HeaderSourceRange, uploadRangeFromUrlOptions.SourceRange.Value());
6877 _detail::HeaderFileRangeWriteFromUrl, uploadRangeFromUrlOptions.XMsWrite.ToString());
6879 _detail::HeaderContentLength,
6880 std::to_string(uploadRangeFromUrlOptions.ContentLength));
6881 if (uploadRangeFromUrlOptions.SourceContentCrc64.HasValue())
6884 _detail::HeaderSourceContentHashCrc64,
6885 _internal::ToBase64String(uploadRangeFromUrlOptions.SourceContentCrc64.Value()));
6887 if (uploadRangeFromUrlOptions.SourceIfMatchCrc64.HasValue())
6890 _detail::HeaderSourceIfMatchHashCrc64,
6891 _internal::ToBase64String(uploadRangeFromUrlOptions.SourceIfMatchCrc64.Value()));
6893 if (uploadRangeFromUrlOptions.SourceIfNoneMatchCrc64.HasValue())
6896 _detail::HeaderSourceIfNoneMatchHashCrc64,
6897 _internal::ToBase64String(
6898 uploadRangeFromUrlOptions.SourceIfNoneMatchCrc64.Value()));
6900 request.SetHeader(_detail::HeaderVersion, uploadRangeFromUrlOptions.ApiVersionParameter);
6901 if (uploadRangeFromUrlOptions.LeaseIdOptional.HasValue())
6904 _detail::HeaderLeaseId, uploadRangeFromUrlOptions.LeaseIdOptional.Value());
6906 return UploadRangeFromUrlParseResult(context, pipeline.Send(request, context));
6909 struct GetRangeListOptions final
6911 Azure::Nullable<std::string> ShareSnapshot;
6912 Azure::Nullable<std::string> PrevShareSnapshot;
6913 Azure::Nullable<int32_t> Timeout;
6914 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6915 Azure::Nullable<std::string> XMsRange;
6916 Azure::Nullable<std::string> LeaseIdOptional;
6919 static Azure::Response<Models::GetFileRangeListResult> GetRangeList(
6920 const Azure::Core::Url& url,
6921 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6922 Azure::Core::Context context,
6923 const GetRangeListOptions& getRangeListOptions)
6925 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
6926 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"rangelist");
6927 if (getRangeListOptions.ShareSnapshot.HasValue())
6929 request.GetUrl().AppendQueryParameter(
6930 _detail::QueryShareSnapshot,
6931 _internal::UrlEncodeQueryParameter(getRangeListOptions.ShareSnapshot.Value()));
6933 if (getRangeListOptions.PrevShareSnapshot.HasValue())
6935 request.GetUrl().AppendQueryParameter(
6936 _detail::QueryPrevShareSnapshot,
6937 _internal::UrlEncodeQueryParameter(getRangeListOptions.PrevShareSnapshot.Value()));
6939 if (getRangeListOptions.Timeout.HasValue())
6941 request.GetUrl().AppendQueryParameter(
6942 _detail::QueryTimeout,
6943 _internal::UrlEncodeQueryParameter(
6944 std::to_string(getRangeListOptions.Timeout.Value())));
6946 request.SetHeader(_detail::HeaderVersion, getRangeListOptions.ApiVersionParameter);
6947 if (getRangeListOptions.XMsRange.HasValue())
6949 request.SetHeader(_detail::HeaderXMsRange, getRangeListOptions.XMsRange.Value());
6951 if (getRangeListOptions.LeaseIdOptional.HasValue())
6953 request.SetHeader(_detail::HeaderLeaseId, getRangeListOptions.LeaseIdOptional.Value());
6955 return GetRangeListParseResult(context, pipeline.Send(request, context));
6958 struct StartCopyOptions final
6960 Azure::Nullable<int32_t> Timeout;
6961 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
6962 Storage::Metadata Metadata;
6963 std::string CopySource;
6964 Azure::Nullable<std::string> FilePermission;
6965 Azure::Nullable<std::string> FilePermissionKey;
6966 Azure::Nullable<PermissionCopyMode> XMsFilePermissionCopyMode;
6967 Azure::Nullable<bool> FileCopyIgnoreReadOnly;
6968 Azure::Nullable<std::string> FileCopyFileAttributes;
6969 Azure::Nullable<std::string> FileCopyFileCreationTime;
6970 Azure::Nullable<std::string> FileCopyFileLastWriteTime;
6971 Azure::Nullable<bool> FileCopySetArchiveAttribute;
6972 Azure::Nullable<std::string> LeaseIdOptional;
6975 static Azure::Response<FileStartCopyResult> StartCopy(
6976 const Azure::Core::Url& url,
6977 Azure::Core::Http::_internal::HttpPipeline& pipeline,
6978 Azure::Core::Context context,
6979 const StartCopyOptions& startCopyOptions)
6981 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
6982 request.SetHeader(_detail::HeaderContentLength,
"0");
6983 if (startCopyOptions.Timeout.HasValue())
6985 request.GetUrl().AppendQueryParameter(
6986 _detail::QueryTimeout,
6987 _internal::UrlEncodeQueryParameter(
6988 std::to_string(startCopyOptions.Timeout.Value())));
6990 request.SetHeader(_detail::HeaderVersion, startCopyOptions.ApiVersionParameter);
6991 for (
const auto& pair : startCopyOptions.Metadata)
6993 request.SetHeader(_detail::HeaderMetadata + (
"-" + pair.first), pair.second);
6995 request.SetHeader(_detail::HeaderCopySource, startCopyOptions.CopySource);
6996 if (startCopyOptions.FilePermission.HasValue())
6999 _detail::HeaderFilePermission, startCopyOptions.FilePermission.Value());
7001 if (startCopyOptions.FilePermissionKey.HasValue())
7004 _detail::HeaderFilePermissionKey, startCopyOptions.FilePermissionKey.Value());
7006 if (startCopyOptions.XMsFilePermissionCopyMode.HasValue())
7009 _detail::HeaderFilePermissionCopyMode,
7010 startCopyOptions.XMsFilePermissionCopyMode.Value().ToString());
7012 if (startCopyOptions.FileCopyIgnoreReadOnly.HasValue())
7015 _detail::HeaderIgnoreReadOnly,
7016 (startCopyOptions.FileCopyIgnoreReadOnly.Value() ?
"true" :
"false"));
7018 if (startCopyOptions.FileCopyFileAttributes.HasValue())
7021 _detail::HeaderFileAttributes, startCopyOptions.FileCopyFileAttributes.Value());
7023 if (startCopyOptions.FileCopyFileCreationTime.HasValue())
7026 _detail::HeaderFileCreatedOn, startCopyOptions.FileCopyFileCreationTime.Value());
7028 if (startCopyOptions.FileCopyFileLastWriteTime.HasValue())
7031 _detail::HeaderFileLastWrittenOn,
7032 startCopyOptions.FileCopyFileLastWriteTime.Value());
7034 if (startCopyOptions.FileCopySetArchiveAttribute.HasValue())
7037 _detail::HeaderSetArchiveAttribute,
7038 (startCopyOptions.FileCopySetArchiveAttribute.Value() ?
"true" :
"false"));
7040 if (startCopyOptions.LeaseIdOptional.HasValue())
7042 request.SetHeader(_detail::HeaderLeaseId, startCopyOptions.LeaseIdOptional.Value());
7044 return StartCopyParseResult(context, pipeline.Send(request, context));
7047 struct AbortCopyOptions final
7050 Azure::Nullable<int32_t> Timeout;
7051 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
7052 Azure::Nullable<std::string> LeaseIdOptional;
7055 static Azure::Response<Models::AbortFileCopyResult> AbortCopy(
7056 const Azure::Core::Url& url,
7057 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7058 Azure::Core::Context context,
7059 const AbortCopyOptions& abortCopyOptions)
7061 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
7062 request.SetHeader(_detail::HeaderContentLength,
"0");
7063 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"copy");
7064 request.GetUrl().AppendQueryParameter(
7065 _detail::QueryCopyId, _internal::UrlEncodeQueryParameter(abortCopyOptions.CopyId));
7066 if (abortCopyOptions.Timeout.HasValue())
7068 request.GetUrl().AppendQueryParameter(
7069 _detail::QueryTimeout,
7070 _internal::UrlEncodeQueryParameter(
7071 std::to_string(abortCopyOptions.Timeout.Value())));
7073 request.SetHeader(_detail::HeaderCopyActionAbortConstant,
"abort");
7074 request.SetHeader(_detail::HeaderVersion, abortCopyOptions.ApiVersionParameter);
7075 if (abortCopyOptions.LeaseIdOptional.HasValue())
7077 request.SetHeader(_detail::HeaderLeaseId, abortCopyOptions.LeaseIdOptional.Value());
7079 return AbortCopyParseResult(context, pipeline.Send(request, context));
7082 struct ListHandlesOptions final
7084 Azure::Nullable<std::string> ContinuationToken;
7085 Azure::Nullable<int32_t> MaxResults;
7086 Azure::Nullable<int32_t> Timeout;
7087 Azure::Nullable<std::string> ShareSnapshot;
7088 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
7091 static Azure::Response<FileListHandlesResult> ListHandles(
7092 const Azure::Core::Url& url,
7093 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7094 Azure::Core::Context context,
7095 const ListHandlesOptions& listHandlesOptions)
7097 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
7098 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"listhandles");
7099 if (listHandlesOptions.ContinuationToken.HasValue())
7101 request.GetUrl().AppendQueryParameter(
7102 _detail::QueryContinuationToken,
7103 _internal::UrlEncodeQueryParameter(listHandlesOptions.ContinuationToken.Value()));
7105 if (listHandlesOptions.MaxResults.HasValue())
7107 request.GetUrl().AppendQueryParameter(
7108 _detail::QueryPageSizeHint,
7109 _internal::UrlEncodeQueryParameter(
7110 std::to_string(listHandlesOptions.MaxResults.Value())));
7112 if (listHandlesOptions.Timeout.HasValue())
7114 request.GetUrl().AppendQueryParameter(
7115 _detail::QueryTimeout,
7116 _internal::UrlEncodeQueryParameter(
7117 std::to_string(listHandlesOptions.Timeout.Value())));
7119 if (listHandlesOptions.ShareSnapshot.HasValue())
7121 request.GetUrl().AppendQueryParameter(
7122 _detail::QueryShareSnapshot,
7123 _internal::UrlEncodeQueryParameter(listHandlesOptions.ShareSnapshot.Value()));
7125 request.SetHeader(_detail::HeaderVersion, listHandlesOptions.ApiVersionParameter);
7126 return ListHandlesParseResult(context, pipeline.Send(request, context));
7129 struct ForceCloseHandlesOptions final
7131 Azure::Nullable<int32_t> Timeout;
7132 Azure::Nullable<std::string> ContinuationToken;
7133 Azure::Nullable<std::string> ShareSnapshot;
7134 std::string HandleId;
7135 std::string ApiVersionParameter = _detail::DefaultServiceApiVersion;
7138 static Azure::Response<FileForceCloseHandlesResult> ForceCloseHandles(
7139 const Azure::Core::Url& url,
7140 Azure::Core::Http::_internal::HttpPipeline& pipeline,
7141 Azure::Core::Context context,
7142 const ForceCloseHandlesOptions& forceCloseHandlesOptions)
7144 Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Put, url);
7145 request.SetHeader(_detail::HeaderContentLength,
"0");
7146 request.GetUrl().AppendQueryParameter(_detail::QueryComp,
"forceclosehandles");
7147 if (forceCloseHandlesOptions.Timeout.HasValue())
7149 request.GetUrl().AppendQueryParameter(
7150 _detail::QueryTimeout,
7151 _internal::UrlEncodeQueryParameter(
7152 std::to_string(forceCloseHandlesOptions.Timeout.Value())));
7154 if (forceCloseHandlesOptions.ContinuationToken.HasValue())
7156 request.GetUrl().AppendQueryParameter(
7157 _detail::QueryContinuationToken,
7158 _internal::UrlEncodeQueryParameter(
7159 forceCloseHandlesOptions.ContinuationToken.Value()));
7161 if (forceCloseHandlesOptions.ShareSnapshot.HasValue())
7163 request.GetUrl().AppendQueryParameter(
7164 _detail::QueryShareSnapshot,
7165 _internal::UrlEncodeQueryParameter(forceCloseHandlesOptions.ShareSnapshot.Value()));
7167 request.SetHeader(_detail::HeaderHandleId, forceCloseHandlesOptions.HandleId);
7168 request.SetHeader(_detail::HeaderVersion, forceCloseHandlesOptions.ApiVersionParameter);
7169 return ForceCloseHandlesParseResult(context, pipeline.Send(request, context));
7173 static Azure::Response<Models::CreateFileResult> CreateParseResult(
7174 Azure::Core::Context context,
7175 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7177 auto& response = *responsePtr;
7178 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
7181 Models::CreateFileResult result;
7182 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7183 result.LastModified = DateTime::Parse(
7184 response.GetHeaders().at(_detail::HeaderLastModified),
7185 DateTime::DateFormat::Rfc1123);
7186 result.IsServerEncrypted
7187 = response.GetHeaders().at(_detail::HeaderRequestIsServerEncrypted) ==
"true";
7188 result.SmbProperties.PermissionKey
7189 = response.GetHeaders().at(_detail::HeaderFilePermissionKey);
7190 result.SmbProperties.Attributes
7191 = FileAttributes(response.GetHeaders().at(_detail::HeaderAttributes));
7192 result.SmbProperties.CreatedOn = DateTime::Parse(
7193 response.GetHeaders().at(_detail::HeaderCreatedOn), DateTime::DateFormat::Rfc3339);
7194 result.SmbProperties.LastWrittenOn = DateTime::Parse(
7195 response.GetHeaders().at(_detail::HeaderLastWrittenOn),
7196 DateTime::DateFormat::Rfc3339);
7197 result.SmbProperties.ChangedOn = DateTime::Parse(
7198 response.GetHeaders().at(_detail::HeaderChangedOn), DateTime::DateFormat::Rfc3339);
7199 result.SmbProperties.FileId = response.GetHeaders().at(_detail::HeaderFileId);
7200 result.SmbProperties.ParentFileId
7201 = response.GetHeaders().at(_detail::HeaderParentFileId);
7202 return Azure::Response<Models::CreateFileResult>(
7203 std::move(result), std::move(responsePtr));
7208 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7212 static Azure::Response<FileDownloadResult> DownloadParseResult(
7213 Azure::Core::Context context,
7214 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7216 auto& response = *responsePtr;
7217 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
7220 FileDownloadResult result;
7221 result.BodyStream = response.ExtractBodyStream();
7222 result.LastModified = DateTime::Parse(
7223 response.GetHeaders().at(_detail::HeaderLastModified),
7224 DateTime::DateFormat::Rfc1123);
7226 for (
auto i = response.GetHeaders().lower_bound(_detail::HeaderMetadata);
7227 i != response.GetHeaders().end()
7228 && i->first.substr(0, 9) == _detail::HeaderMetadata;
7231 result.Metadata.emplace(i->first.substr(10), i->second);
7233 result.HttpHeaders.ContentType = response.GetHeaders().at(_detail::HeaderContentType);
7235 auto content_range_iterator = response.GetHeaders().find(_detail::HeaderContentRange);
7236 if (content_range_iterator != response.GetHeaders().end())
7238 const std::string& content_range = content_range_iterator->second;
7239 auto bytes_pos = content_range.find(
"bytes ");
7240 auto dash_pos = content_range.find(
"-", bytes_pos + 6);
7241 auto slash_pos = content_range.find(
"/", dash_pos + 1);
7242 int64_t range_start_offset = std::stoll(std::string(
7243 content_range.begin() + bytes_pos + 6, content_range.begin() + dash_pos));
7244 int64_t range_end_offset = std::stoll(std::string(
7245 content_range.begin() + dash_pos + 1, content_range.begin() + slash_pos));
7246 result.ContentRange = Azure::Core::Http::HttpRange{
7247 range_start_offset, range_end_offset - range_start_offset + 1};
7251 result.ContentRange = Azure::Core::Http::HttpRange{
7252 0, std::stoll(response.GetHeaders().at(_detail::HeaderContentLength))};
7254 if (content_range_iterator != response.GetHeaders().end())
7256 const std::string& content_range = content_range_iterator->second;
7257 auto slash_pos = content_range.find(
"/");
7258 result.FileSize = std::stoll(content_range.substr(slash_pos + 1));
7262 result.FileSize = std::stoll(response.GetHeaders().at(_detail::HeaderContentLength));
7264 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7265 if (response.GetHeaders().find(_detail::HeaderTransactionalContentHashMd5)
7266 != response.GetHeaders().end())
7268 result.TransactionalContentHash = _internal::FromBase64String(
7269 response.GetHeaders().at(_detail::HeaderTransactionalContentHashMd5),
7270 HashAlgorithm::Md5);
7272 if (response.GetHeaders().find(_detail::HeaderContentEncoding)
7273 != response.GetHeaders().end())
7275 result.HttpHeaders.ContentEncoding
7276 = response.GetHeaders().at(_detail::HeaderContentEncoding);
7278 if (response.GetHeaders().find(_detail::HeaderCacheControl)
7279 != response.GetHeaders().end())
7281 result.HttpHeaders.CacheControl
7282 = response.GetHeaders().at(_detail::HeaderCacheControl);
7284 if (response.GetHeaders().find(_detail::HeaderContentDisposition)
7285 != response.GetHeaders().end())
7287 result.HttpHeaders.ContentDisposition
7288 = response.GetHeaders().at(_detail::HeaderContentDisposition);
7290 if (response.GetHeaders().find(_detail::HeaderContentLanguage)
7291 != response.GetHeaders().end())
7293 result.HttpHeaders.ContentLanguage
7294 = response.GetHeaders().at(_detail::HeaderContentLanguage);
7296 result.AcceptRanges = response.GetHeaders().at(_detail::HeaderAcceptRanges);
7297 if (response.GetHeaders().find(_detail::HeaderCopyCompletedOn)
7298 != response.GetHeaders().end())
7300 result.CopyCompletedOn = DateTime::Parse(
7301 response.GetHeaders().at(_detail::HeaderCopyCompletedOn),
7302 DateTime::DateFormat::Rfc1123);
7304 if (response.GetHeaders().find(_detail::HeaderCopyStatusDescription)
7305 != response.GetHeaders().end())
7307 result.CopyStatusDescription
7308 = response.GetHeaders().at(_detail::HeaderCopyStatusDescription);
7310 if (response.GetHeaders().find(_detail::HeaderCopyId) != response.GetHeaders().end())
7312 result.CopyId = response.GetHeaders().at(_detail::HeaderCopyId);
7314 if (response.GetHeaders().find(_detail::HeaderCopyProgress)
7315 != response.GetHeaders().end())
7317 result.CopyProgress = response.GetHeaders().at(_detail::HeaderCopyProgress);
7319 if (response.GetHeaders().find(_detail::HeaderCopySource)
7320 != response.GetHeaders().end())
7322 result.CopySource = response.GetHeaders().at(_detail::HeaderCopySource);
7324 if (response.GetHeaders().find(_detail::HeaderCopyStatus)
7325 != response.GetHeaders().end())
7327 result.CopyStatus = CopyStatus(response.GetHeaders().at(_detail::HeaderCopyStatus));
7329 if (response.GetHeaders().find(_detail::HeaderContentHashMd5)
7330 != response.GetHeaders().end())
7332 result.HttpHeaders.ContentHash = _internal::FromBase64String(
7333 response.GetHeaders().at(_detail::HeaderContentHashMd5), HashAlgorithm::Md5);
7335 if (response.GetHeaders().find(_detail::HeaderIsServerEncrypted)
7336 != response.GetHeaders().end())
7338 result.IsServerEncrypted
7339 = response.GetHeaders().at(_detail::HeaderIsServerEncrypted) ==
"true";
7341 result.SmbProperties.Attributes
7342 = FileAttributes(response.GetHeaders().at(_detail::HeaderAttributes));
7343 result.SmbProperties.CreatedOn = DateTime::Parse(
7344 response.GetHeaders().at(_detail::HeaderCreatedOn), DateTime::DateFormat::Rfc3339);
7345 result.SmbProperties.LastWrittenOn = DateTime::Parse(
7346 response.GetHeaders().at(_detail::HeaderLastWrittenOn),
7347 DateTime::DateFormat::Rfc3339);
7348 result.SmbProperties.ChangedOn = DateTime::Parse(
7349 response.GetHeaders().at(_detail::HeaderChangedOn), DateTime::DateFormat::Rfc3339);
7350 result.SmbProperties.PermissionKey
7351 = response.GetHeaders().at(_detail::HeaderFilePermissionKey);
7352 result.SmbProperties.FileId = response.GetHeaders().at(_detail::HeaderFileId);
7353 result.SmbProperties.ParentFileId
7354 = response.GetHeaders().at(_detail::HeaderParentFileId);
7355 if (response.GetHeaders().find(_detail::HeaderLeaseDuration)
7356 != response.GetHeaders().end())
7358 result.LeaseDuration
7359 = LeaseDuration(response.GetHeaders().at(_detail::HeaderLeaseDuration));
7361 if (response.GetHeaders().find(_detail::HeaderLeaseState)
7362 != response.GetHeaders().end())
7364 result.LeaseState = LeaseState(response.GetHeaders().at(_detail::HeaderLeaseState));
7366 if (response.GetHeaders().find(_detail::HeaderLeaseStatus)
7367 != response.GetHeaders().end())
7370 = LeaseStatus(response.GetHeaders().at(_detail::HeaderLeaseStatus));
7372 return Azure::Response<FileDownloadResult>(std::move(result), std::move(responsePtr));
7374 else if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::PartialContent)
7377 FileDownloadResult result;
7378 result.BodyStream = response.ExtractBodyStream();
7379 result.LastModified = DateTime::Parse(
7380 response.GetHeaders().at(_detail::HeaderLastModified),
7381 DateTime::DateFormat::Rfc1123);
7383 for (
auto i = response.GetHeaders().lower_bound(_detail::HeaderMetadata);
7384 i != response.GetHeaders().end()
7385 && i->first.substr(0, 9) == _detail::HeaderMetadata;
7388 result.Metadata.emplace(i->first.substr(10), i->second);
7390 result.HttpHeaders.ContentType = response.GetHeaders().at(_detail::HeaderContentType);
7392 auto content_range_iterator = response.GetHeaders().find(_detail::HeaderContentRange);
7393 if (content_range_iterator != response.GetHeaders().end())
7395 const std::string& content_range = content_range_iterator->second;
7396 auto bytes_pos = content_range.find(
"bytes ");
7397 auto dash_pos = content_range.find(
"-", bytes_pos + 6);
7398 auto slash_pos = content_range.find(
"/", dash_pos + 1);
7399 int64_t range_start_offset = std::stoll(std::string(
7400 content_range.begin() + bytes_pos + 6, content_range.begin() + dash_pos));
7401 int64_t range_end_offset = std::stoll(std::string(
7402 content_range.begin() + dash_pos + 1, content_range.begin() + slash_pos));
7403 result.ContentRange = Azure::Core::Http::HttpRange{
7404 range_start_offset, range_end_offset - range_start_offset + 1};
7408 result.ContentRange = Azure::Core::Http::HttpRange{
7409 0, std::stoll(response.GetHeaders().at(_detail::HeaderContentLength))};
7411 if (content_range_iterator != response.GetHeaders().end())
7413 const std::string& content_range = content_range_iterator->second;
7414 auto slash_pos = content_range.find(
"/");
7415 result.FileSize = std::stoll(content_range.substr(slash_pos + 1));
7419 result.FileSize = std::stoll(response.GetHeaders().at(_detail::HeaderContentLength));
7421 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7422 if (response.GetHeaders().find(_detail::HeaderTransactionalContentHashMd5)
7423 != response.GetHeaders().end())
7425 result.TransactionalContentHash = _internal::FromBase64String(
7426 response.GetHeaders().at(_detail::HeaderTransactionalContentHashMd5),
7427 HashAlgorithm::Md5);
7429 if (response.GetHeaders().find(_detail::HeaderContentEncoding)
7430 != response.GetHeaders().end())
7432 result.HttpHeaders.ContentEncoding
7433 = response.GetHeaders().at(_detail::HeaderContentEncoding);
7435 if (response.GetHeaders().find(_detail::HeaderCacheControl)
7436 != response.GetHeaders().end())
7438 result.HttpHeaders.CacheControl
7439 = response.GetHeaders().at(_detail::HeaderCacheControl);
7441 if (response.GetHeaders().find(_detail::HeaderContentDisposition)
7442 != response.GetHeaders().end())
7444 result.HttpHeaders.ContentDisposition
7445 = response.GetHeaders().at(_detail::HeaderContentDisposition);
7447 if (response.GetHeaders().find(_detail::HeaderContentLanguage)
7448 != response.GetHeaders().end())
7450 result.HttpHeaders.ContentLanguage
7451 = response.GetHeaders().at(_detail::HeaderContentLanguage);
7453 result.AcceptRanges = response.GetHeaders().at(_detail::HeaderAcceptRanges);
7454 if (response.GetHeaders().find(_detail::HeaderCopyCompletedOn)
7455 != response.GetHeaders().end())
7457 result.CopyCompletedOn = DateTime::Parse(
7458 response.GetHeaders().at(_detail::HeaderCopyCompletedOn),
7459 DateTime::DateFormat::Rfc1123);
7461 if (response.GetHeaders().find(_detail::HeaderCopyStatusDescription)
7462 != response.GetHeaders().end())
7464 result.CopyStatusDescription
7465 = response.GetHeaders().at(_detail::HeaderCopyStatusDescription);
7467 if (response.GetHeaders().find(_detail::HeaderCopyId) != response.GetHeaders().end())
7469 result.CopyId = response.GetHeaders().at(_detail::HeaderCopyId);
7471 if (response.GetHeaders().find(_detail::HeaderCopyProgress)
7472 != response.GetHeaders().end())
7474 result.CopyProgress = response.GetHeaders().at(_detail::HeaderCopyProgress);
7476 if (response.GetHeaders().find(_detail::HeaderCopySource)
7477 != response.GetHeaders().end())
7479 result.CopySource = response.GetHeaders().at(_detail::HeaderCopySource);
7481 if (response.GetHeaders().find(_detail::HeaderCopyStatus)
7482 != response.GetHeaders().end())
7484 result.CopyStatus = CopyStatus(response.GetHeaders().at(_detail::HeaderCopyStatus));
7486 if (response.GetHeaders().find(_detail::HeaderContentHashMd5)
7487 != response.GetHeaders().end())
7489 result.HttpHeaders.ContentHash = _internal::FromBase64String(
7490 response.GetHeaders().at(_detail::HeaderContentHashMd5), HashAlgorithm::Md5);
7492 if (response.GetHeaders().find(_detail::HeaderIsServerEncrypted)
7493 != response.GetHeaders().end())
7495 result.IsServerEncrypted
7496 = response.GetHeaders().at(_detail::HeaderIsServerEncrypted) ==
"true";
7498 result.SmbProperties.Attributes
7499 = FileAttributes(response.GetHeaders().at(_detail::HeaderAttributes));
7500 result.SmbProperties.CreatedOn = DateTime::Parse(
7501 response.GetHeaders().at(_detail::HeaderCreatedOn), DateTime::DateFormat::Rfc3339);
7502 result.SmbProperties.LastWrittenOn = DateTime::Parse(
7503 response.GetHeaders().at(_detail::HeaderLastWrittenOn),
7504 DateTime::DateFormat::Rfc3339);
7505 result.SmbProperties.ChangedOn = DateTime::Parse(
7506 response.GetHeaders().at(_detail::HeaderChangedOn), DateTime::DateFormat::Rfc3339);
7507 result.SmbProperties.PermissionKey
7508 = response.GetHeaders().at(_detail::HeaderFilePermissionKey);
7509 result.SmbProperties.FileId = response.GetHeaders().at(_detail::HeaderFileId);
7510 result.SmbProperties.ParentFileId
7511 = response.GetHeaders().at(_detail::HeaderParentFileId);
7512 if (response.GetHeaders().find(_detail::HeaderLeaseDuration)
7513 != response.GetHeaders().end())
7515 result.LeaseDuration
7516 = LeaseDuration(response.GetHeaders().at(_detail::HeaderLeaseDuration));
7518 if (response.GetHeaders().find(_detail::HeaderLeaseState)
7519 != response.GetHeaders().end())
7521 result.LeaseState = LeaseState(response.GetHeaders().at(_detail::HeaderLeaseState));
7523 if (response.GetHeaders().find(_detail::HeaderLeaseStatus)
7524 != response.GetHeaders().end())
7527 = LeaseStatus(response.GetHeaders().at(_detail::HeaderLeaseStatus));
7529 return Azure::Response<FileDownloadResult>(std::move(result), std::move(responsePtr));
7534 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7538 static Azure::Response<Models::FileProperties> GetPropertiesParseResult(
7539 Azure::Core::Context context,
7540 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7542 auto& response = *responsePtr;
7543 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
7546 Models::FileProperties result;
7547 result.LastModified = DateTime::Parse(
7548 response.GetHeaders().at(_detail::HeaderLastModified),
7549 DateTime::DateFormat::Rfc1123);
7551 for (
auto i = response.GetHeaders().lower_bound(_detail::HeaderMetadata);
7552 i != response.GetHeaders().end()
7553 && i->first.substr(0, 9) == _detail::HeaderMetadata;
7556 result.Metadata.emplace(i->first.substr(10), i->second);
7558 result.FileSize = std::stoll(response.GetHeaders().at(_detail::HeaderContentLength));
7559 if (response.GetHeaders().find(_detail::HeaderContentType)
7560 != response.GetHeaders().end())
7562 result.HttpHeaders.ContentType = response.GetHeaders().at(_detail::HeaderContentType);
7564 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7565 if (response.GetHeaders().find(_detail::HeaderTransactionalContentHashMd5)
7566 != response.GetHeaders().end())
7568 result.HttpHeaders.ContentHash = _internal::FromBase64String(
7569 response.GetHeaders().at(_detail::HeaderTransactionalContentHashMd5),
7570 HashAlgorithm::Md5);
7572 if (response.GetHeaders().find(_detail::HeaderContentEncoding)
7573 != response.GetHeaders().end())
7575 result.HttpHeaders.ContentEncoding
7576 = response.GetHeaders().at(_detail::HeaderContentEncoding);
7578 if (response.GetHeaders().find(_detail::HeaderCacheControl)
7579 != response.GetHeaders().end())
7581 result.HttpHeaders.CacheControl
7582 = response.GetHeaders().at(_detail::HeaderCacheControl);
7584 if (response.GetHeaders().find(_detail::HeaderContentDisposition)
7585 != response.GetHeaders().end())
7587 result.HttpHeaders.ContentDisposition
7588 = response.GetHeaders().at(_detail::HeaderContentDisposition);
7590 if (response.GetHeaders().find(_detail::HeaderContentLanguage)
7591 != response.GetHeaders().end())
7593 result.HttpHeaders.ContentLanguage
7594 = response.GetHeaders().at(_detail::HeaderContentLanguage);
7596 if (response.GetHeaders().find(_detail::HeaderCopyCompletedOn)
7597 != response.GetHeaders().end())
7599 result.CopyCompletedOn = DateTime::Parse(
7600 response.GetHeaders().at(_detail::HeaderCopyCompletedOn),
7601 DateTime::DateFormat::Rfc1123);
7603 if (response.GetHeaders().find(_detail::HeaderCopyStatusDescription)
7604 != response.GetHeaders().end())
7606 result.CopyStatusDescription
7607 = response.GetHeaders().at(_detail::HeaderCopyStatusDescription);
7609 if (response.GetHeaders().find(_detail::HeaderCopyId) != response.GetHeaders().end())
7611 result.CopyId = response.GetHeaders().at(_detail::HeaderCopyId);
7613 if (response.GetHeaders().find(_detail::HeaderCopyProgress)
7614 != response.GetHeaders().end())
7616 result.CopyProgress = response.GetHeaders().at(_detail::HeaderCopyProgress);
7618 if (response.GetHeaders().find(_detail::HeaderCopySource)
7619 != response.GetHeaders().end())
7621 result.CopySource = response.GetHeaders().at(_detail::HeaderCopySource);
7623 if (response.GetHeaders().find(_detail::HeaderCopyStatus)
7624 != response.GetHeaders().end())
7626 result.CopyStatus = CopyStatus(response.GetHeaders().at(_detail::HeaderCopyStatus));
7628 if (response.GetHeaders().find(_detail::HeaderIsServerEncrypted)
7629 != response.GetHeaders().end())
7631 result.IsServerEncrypted
7632 = response.GetHeaders().at(_detail::HeaderIsServerEncrypted) ==
"true";
7634 result.SmbProperties.Attributes
7635 = FileAttributes(response.GetHeaders().at(_detail::HeaderAttributes));
7636 result.SmbProperties.CreatedOn = DateTime::Parse(
7637 response.GetHeaders().at(_detail::HeaderCreatedOn), DateTime::DateFormat::Rfc3339);
7638 result.SmbProperties.LastWrittenOn = DateTime::Parse(
7639 response.GetHeaders().at(_detail::HeaderLastWrittenOn),
7640 DateTime::DateFormat::Rfc3339);
7641 result.SmbProperties.ChangedOn = DateTime::Parse(
7642 response.GetHeaders().at(_detail::HeaderChangedOn), DateTime::DateFormat::Rfc3339);
7643 result.SmbProperties.PermissionKey
7644 = response.GetHeaders().at(_detail::HeaderFilePermissionKey);
7645 result.SmbProperties.FileId = response.GetHeaders().at(_detail::HeaderFileId);
7646 result.SmbProperties.ParentFileId
7647 = response.GetHeaders().at(_detail::HeaderParentFileId);
7648 if (response.GetHeaders().find(_detail::HeaderLeaseDuration)
7649 != response.GetHeaders().end())
7651 result.LeaseDuration
7652 = LeaseDuration(response.GetHeaders().at(_detail::HeaderLeaseDuration));
7654 if (response.GetHeaders().find(_detail::HeaderLeaseState)
7655 != response.GetHeaders().end())
7657 result.LeaseState = LeaseState(response.GetHeaders().at(_detail::HeaderLeaseState));
7659 if (response.GetHeaders().find(_detail::HeaderLeaseStatus)
7660 != response.GetHeaders().end())
7663 = LeaseStatus(response.GetHeaders().at(_detail::HeaderLeaseStatus));
7665 return Azure::Response<Models::FileProperties>(
7666 std::move(result), std::move(responsePtr));
7671 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7675 static Azure::Response<Models::DeleteFileResult> DeleteParseResult(
7676 Azure::Core::Context context,
7677 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7679 auto& response = *responsePtr;
7680 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)
7683 Models::DeleteFileResult result;
7684 return Azure::Response<Models::DeleteFileResult>(
7685 std::move(result), std::move(responsePtr));
7690 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7694 static Azure::Response<Models::SetFilePropertiesResult> SetHttpHeadersParseResult(
7695 Azure::Core::Context context,
7696 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7698 auto& response = *responsePtr;
7699 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
7702 Models::SetFilePropertiesResult result;
7703 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7704 result.LastModified = DateTime::Parse(
7705 response.GetHeaders().at(_detail::HeaderLastModified),
7706 DateTime::DateFormat::Rfc1123);
7707 result.IsServerEncrypted
7708 = response.GetHeaders().at(_detail::HeaderRequestIsServerEncrypted) ==
"true";
7709 result.SmbProperties.PermissionKey
7710 = response.GetHeaders().at(_detail::HeaderFilePermissionKey);
7711 result.SmbProperties.Attributes
7712 = FileAttributes(response.GetHeaders().at(_detail::HeaderAttributes));
7713 result.SmbProperties.CreatedOn = DateTime::Parse(
7714 response.GetHeaders().at(_detail::HeaderCreatedOn), DateTime::DateFormat::Rfc3339);
7715 result.SmbProperties.LastWrittenOn = DateTime::Parse(
7716 response.GetHeaders().at(_detail::HeaderLastWrittenOn),
7717 DateTime::DateFormat::Rfc3339);
7718 result.SmbProperties.ChangedOn = DateTime::Parse(
7719 response.GetHeaders().at(_detail::HeaderChangedOn), DateTime::DateFormat::Rfc3339);
7720 result.SmbProperties.FileId = response.GetHeaders().at(_detail::HeaderFileId);
7721 result.SmbProperties.ParentFileId
7722 = response.GetHeaders().at(_detail::HeaderParentFileId);
7723 return Azure::Response<Models::SetFilePropertiesResult>(
7724 std::move(result), std::move(responsePtr));
7729 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7733 static Azure::Response<Models::SetFileMetadataResult> SetMetadataParseResult(
7734 Azure::Core::Context context,
7735 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7737 auto& response = *responsePtr;
7738 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
7741 Models::SetFileMetadataResult result;
7742 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7743 result.IsServerEncrypted
7744 = response.GetHeaders().at(_detail::HeaderRequestIsServerEncrypted) ==
"true";
7745 return Azure::Response<Models::SetFileMetadataResult>(
7746 std::move(result), std::move(responsePtr));
7751 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7755 static Azure::Response<FileAcquireLeaseResult> AcquireLeaseParseResult(
7756 Azure::Core::Context context,
7757 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7759 auto& response = *responsePtr;
7760 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
7763 FileAcquireLeaseResult result;
7764 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7765 result.LastModified = DateTime::Parse(
7766 response.GetHeaders().at(_detail::HeaderLastModified),
7767 DateTime::DateFormat::Rfc1123);
7768 result.LeaseId = response.GetHeaders().at(_detail::HeaderLeaseId);
7769 return Azure::Response<FileAcquireLeaseResult>(
7770 std::move(result), std::move(responsePtr));
7775 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7779 static Azure::Response<FileReleaseLeaseResult> ReleaseLeaseParseResult(
7780 Azure::Core::Context context,
7781 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7783 auto& response = *responsePtr;
7784 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
7787 FileReleaseLeaseResult result;
7788 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7789 result.LastModified = DateTime::Parse(
7790 response.GetHeaders().at(_detail::HeaderLastModified),
7791 DateTime::DateFormat::Rfc1123);
7792 return Azure::Response<FileReleaseLeaseResult>(
7793 std::move(result), std::move(responsePtr));
7798 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7802 static Azure::Response<FileChangeLeaseResult> ChangeLeaseParseResult(
7803 Azure::Core::Context context,
7804 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7806 auto& response = *responsePtr;
7807 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
7810 FileChangeLeaseResult result;
7811 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7812 result.LastModified = DateTime::Parse(
7813 response.GetHeaders().at(_detail::HeaderLastModified),
7814 DateTime::DateFormat::Rfc1123);
7815 result.LeaseId = response.GetHeaders().at(_detail::HeaderLeaseId);
7816 return Azure::Response<FileChangeLeaseResult>(
7817 std::move(result), std::move(responsePtr));
7822 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7826 static Azure::Response<FileBreakLeaseResult> BreakLeaseParseResult(
7827 Azure::Core::Context context,
7828 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7830 auto& response = *responsePtr;
7831 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)
7834 FileBreakLeaseResult result;
7835 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7836 result.LastModified = DateTime::Parse(
7837 response.GetHeaders().at(_detail::HeaderLastModified),
7838 DateTime::DateFormat::Rfc1123);
7839 if (response.GetHeaders().find(_detail::HeaderLeaseId) != response.GetHeaders().end())
7841 result.LeaseId = response.GetHeaders().at(_detail::HeaderLeaseId);
7843 return Azure::Response<FileBreakLeaseResult>(std::move(result), std::move(responsePtr));
7848 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7852 static Azure::Response<Models::UploadFileRangeResult> UploadRangeParseResult(
7853 Azure::Core::Context context,
7854 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7856 auto& response = *responsePtr;
7857 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
7860 Models::UploadFileRangeResult result;
7861 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7862 result.LastModified = DateTime::Parse(
7863 response.GetHeaders().at(_detail::HeaderLastModified),
7864 DateTime::DateFormat::Rfc1123);
7865 if (response.GetHeaders().find(_detail::HeaderTransactionalContentHashMd5)
7866 != response.GetHeaders().end())
7868 result.TransactionalContentHash = _internal::FromBase64String(
7869 response.GetHeaders().at(_detail::HeaderTransactionalContentHashMd5),
7870 HashAlgorithm::Md5);
7872 if (response.GetHeaders().find(_detail::HeaderRequestIsServerEncrypted)
7873 != response.GetHeaders().end())
7875 result.IsServerEncrypted
7876 = response.GetHeaders().at(_detail::HeaderRequestIsServerEncrypted) ==
"true";
7878 return Azure::Response<Models::UploadFileRangeResult>(
7879 std::move(result), std::move(responsePtr));
7884 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7888 static Azure::Response<Models::UploadFileRangeFromUriResult> UploadRangeFromUrlParseResult(
7889 Azure::Core::Context context,
7890 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7892 auto& response = *responsePtr;
7893 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Created)
7896 Models::UploadFileRangeFromUriResult result;
7897 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7898 result.LastModified = DateTime::Parse(
7899 response.GetHeaders().at(_detail::HeaderLastModified),
7900 DateTime::DateFormat::Rfc1123);
7901 result.TransactionalContentHash = _internal::FromBase64String(
7902 response.GetHeaders().at(_detail::HeaderTransactionalContentHashCrc64),
7903 HashAlgorithm::Crc64);
7904 result.IsServerEncrypted
7905 = response.GetHeaders().at(_detail::HeaderRequestIsServerEncrypted) ==
"true";
7906 return Azure::Response<Models::UploadFileRangeFromUriResult>(
7907 std::move(result), std::move(responsePtr));
7912 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7916 static Azure::Response<Models::GetFileRangeListResult> GetRangeListParseResult(
7917 Azure::Core::Context context,
7918 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
7920 auto& response = *responsePtr;
7921 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
7924 const auto& bodyBuffer = response.GetBody();
7925 auto reader = _internal::XmlReader(
7926 reinterpret_cast<const char*
>(bodyBuffer.data()), bodyBuffer.size());
7927 Models::GetFileRangeListResult result = bodyBuffer.empty()
7928 ? Models::GetFileRangeListResult()
7929 : GetFileRangeListResultFromRangeList(RangeListFromXml(reader));
7930 result.LastModified = DateTime::Parse(
7931 response.GetHeaders().at(_detail::HeaderLastModified),
7932 DateTime::DateFormat::Rfc1123);
7933 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
7934 result.FileSize = std::stoll(response.GetHeaders().at(_detail::HeaderXMsContentLength));
7935 return Azure::Response<Models::GetFileRangeListResult>(
7936 std::move(result), std::move(responsePtr));
7941 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
7945 static RangeList RangeListFromXml(_internal::XmlReader& reader)
7947 auto result = RangeList();
7948 enum class XmlTagName
7955 std::vector<XmlTagName> path;
7959 auto node = reader.Read();
7960 if (node.Type == _internal::XmlNodeType::End)
7964 else if (node.Type == _internal::XmlNodeType::EndTag)
7966 if (path.size() > 0)
7975 else if (node.Type == _internal::XmlNodeType::StartTag)
7978 if (std::strcmp(node.Name,
"ClearRange") == 0)
7980 path.emplace_back(XmlTagName::ClearRange);
7982 else if (std::strcmp(node.Name,
"Range") == 0)
7984 path.emplace_back(XmlTagName::Range);
7986 else if (std::strcmp(node.Name,
"Ranges") == 0)
7988 path.emplace_back(XmlTagName::Ranges);
7992 path.emplace_back(XmlTagName::Unknown);
7994 if (path.size() == 2 && path[0] == XmlTagName::Ranges && path[1] == XmlTagName::Range)
7996 result.Ranges.emplace_back(HttpRangeFromXml(reader));
8000 path.size() == 2 && path[0] == XmlTagName::Ranges
8001 && path[1] == XmlTagName::ClearRange)
8003 result.ClearRanges.emplace_back(HttpRangeFromXml(reader));
8007 else if (node.Type == _internal::XmlNodeType::Text)
8014 static Models::GetFileRangeListResult GetFileRangeListResultFromRangeList(RangeList
object)
8016 Models::GetFileRangeListResult result;
8017 result.Ranges = std::move(
object.Ranges);
8018 result.ClearRanges = std::move(
object.ClearRanges);
8022 static Azure::Response<FileStartCopyResult> StartCopyParseResult(
8023 Azure::Core::Context context,
8024 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
8026 auto& response = *responsePtr;
8027 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Accepted)
8030 FileStartCopyResult result;
8031 result.ETag = Azure::ETag(response.GetHeaders().at(_detail::HeaderETag));
8032 result.LastModified = DateTime::Parse(
8033 response.GetHeaders().at(_detail::HeaderLastModified),
8034 DateTime::DateFormat::Rfc1123);
8035 if (response.GetHeaders().find(_detail::HeaderCopyId) != response.GetHeaders().end())
8037 result.CopyId = response.GetHeaders().at(_detail::HeaderCopyId);
8039 if (response.GetHeaders().find(_detail::HeaderCopyStatus)
8040 != response.GetHeaders().end())
8042 result.CopyStatus = CopyStatus(response.GetHeaders().at(_detail::HeaderCopyStatus));
8044 return Azure::Response<FileStartCopyResult>(std::move(result), std::move(responsePtr));
8049 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
8053 static Azure::Response<Models::AbortFileCopyResult> AbortCopyParseResult(
8054 Azure::Core::Context context,
8055 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
8057 auto& response = *responsePtr;
8058 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::NoContent)
8061 Models::AbortFileCopyResult result;
8062 return Azure::Response<Models::AbortFileCopyResult>(
8063 std::move(result), std::move(responsePtr));
8068 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
8072 static Azure::Response<FileListHandlesResult> ListHandlesParseResult(
8073 Azure::Core::Context context,
8074 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
8076 auto& response = *responsePtr;
8077 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
8080 const auto& bodyBuffer = response.GetBody();
8081 auto reader = _internal::XmlReader(
8082 reinterpret_cast<const char*
>(bodyBuffer.data()), bodyBuffer.size());
8083 FileListHandlesResult result = bodyBuffer.empty()
8084 ? FileListHandlesResult()
8085 : FileListHandlesResultFromListHandlesResponse(ListHandlesResponseFromXml(reader));
8086 result.HttpHeaders.ContentType = response.GetHeaders().at(_detail::HeaderContentType);
8087 return Azure::Response<FileListHandlesResult>(
8088 std::move(result), std::move(responsePtr));
8093 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));
8097 static HandleItem HandleItemFromXml(_internal::XmlReader& reader)
8099 auto result = HandleItem();
8100 enum class XmlTagName
8112 std::vector<XmlTagName> path;
8116 auto node = reader.Read();
8117 if (node.Type == _internal::XmlNodeType::End)
8121 else if (node.Type == _internal::XmlNodeType::EndTag)
8123 if (path.size() > 0)
8132 else if (node.Type == _internal::XmlNodeType::StartTag)
8135 if (std::strcmp(node.Name,
"ClientIp") == 0)
8137 path.emplace_back(XmlTagName::ClientIp);
8139 else if (std::strcmp(node.Name,
"FileId") == 0)
8141 path.emplace_back(XmlTagName::FileId);
8143 else if (std::strcmp(node.Name,
"HandleId") == 0)
8145 path.emplace_back(XmlTagName::HandleId);
8147 else if (std::strcmp(node.Name,
"LastReconnectTime") == 0)
8149 path.emplace_back(XmlTagName::LastReconnectTime);
8151 else if (std::strcmp(node.Name,
"OpenTime") == 0)
8153 path.emplace_back(XmlTagName::OpenTime);
8155 else if (std::strcmp(node.Name,
"ParentId") == 0)
8157 path.emplace_back(XmlTagName::ParentId);
8159 else if (std::strcmp(node.Name,
"Path") == 0)
8161 path.emplace_back(XmlTagName::Path);
8163 else if (std::strcmp(node.Name,
"SessionId") == 0)
8165 path.emplace_back(XmlTagName::SessionId);
8169 path.emplace_back(XmlTagName::Unknown);
8172 else if (node.Type == _internal::XmlNodeType::Text)
8174 if (path.size() == 1 && path[0] == XmlTagName::ClientIp)
8176 result.ClientIp = node.Value;
8178 else if (path.size() == 1 && path[0] == XmlTagName::FileId)
8180 result.FileId = node.Value;
8182 else if (path.size() == 1 && path[0] == XmlTagName::HandleId)
8184 result.HandleId = node.Value;
8186 else if (path.size() == 1 && path[0] == XmlTagName::LastReconnectTime)
8188 result.LastReconnectedOn
8189 = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc1123);
8191 else if (path.size() == 1 && path[0] == XmlTagName::OpenTime)
8193 result.OpenedOn = DateTime::Parse(node.Value, DateTime::DateFormat::Rfc1123);
8195 else if (path.size() == 1 && path[0] == XmlTagName::ParentId)
8197 result.ParentId = node.Value;
8199 else if (path.size() == 1 && path[0] == XmlTagName::Path)
8201 result.Path = node.Value;
8203 else if (path.size() == 1 && path[0] == XmlTagName::SessionId)
8205 result.SessionId = node.Value;
8212 static ListHandlesResponse ListHandlesResponseFromXml(_internal::XmlReader& reader)
8214 auto result = ListHandlesResponse();
8215 enum class XmlTagName
8223 std::vector<XmlTagName> path;
8227 auto node = reader.Read();
8228 if (node.Type == _internal::XmlNodeType::End)
8232 else if (node.Type == _internal::XmlNodeType::EndTag)
8234 if (path.size() > 0)
8243 else if (node.Type == _internal::XmlNodeType::StartTag)
8246 if (std::strcmp(node.Name,
"Entries") == 0)
8248 path.emplace_back(XmlTagName::Entries);
8250 else if (std::strcmp(node.Name,
"EnumerationResults") == 0)
8252 path.emplace_back(XmlTagName::EnumerationResults);
8254 else if (std::strcmp(node.Name,
"Handle") == 0)
8256 path.emplace_back(XmlTagName::Handle);
8258 else if (std::strcmp(node.Name,
"NextMarker") == 0)
8260 path.emplace_back(XmlTagName::NextMarker);
8264 path.emplace_back(XmlTagName::Unknown);
8266 if (path.size() == 3 && path[0] == XmlTagName::EnumerationResults
8267 && path[1] == XmlTagName::Entries && path[2] == XmlTagName::Handle)
8269 result.HandleList.emplace_back(HandleItemFromXml(reader));
8273 else if (node.Type == _internal::XmlNodeType::Text)
8275 if (path.size() == 2 && path[0] == XmlTagName::EnumerationResults
8276 && path[1] == XmlTagName::NextMarker)
8278 result.ContinuationToken = node.Value;
8285 static FileListHandlesResult FileListHandlesResultFromListHandlesResponse(
8286 ListHandlesResponse
object)
8288 FileListHandlesResult result;
8289 result.HandleList = std::move(
object.HandleList);
8290 result.ContinuationToken = std::move(
object.ContinuationToken);
8294 static Azure::Response<FileForceCloseHandlesResult> ForceCloseHandlesParseResult(
8295 Azure::Core::Context context,
8296 std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
8298 auto& response = *responsePtr;
8299 if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
8302 FileForceCloseHandlesResult result;
8303 if (response.GetHeaders().find(_detail::HeaderContinuationToken)
8304 != response.GetHeaders().end())
8306 result.ContinuationToken = response.GetHeaders().at(_detail::HeaderContinuationToken);
8308 result.NumberOfHandlesClosed
8309 = std::stoi(response.GetHeaders().at(_detail::HeaderNumberOfHandlesClosed));
8310 result.NumberOfHandlesFailedToClose
8311 = std::stoi(response.GetHeaders().at(_detail::HeaderNumberOfHandlesFailedToClose));
8312 return Azure::Response<FileForceCloseHandlesResult>(
8313 std::move(result), std::move(responsePtr));
8318 throw Storage::StorageException::CreateFromResponse(std::move(responsePtr));