bucket_metadata.h

Go to the documentation of this file.

// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_BUCKET_METADATA_H
#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_BUCKET_METADATA_H
 
#include "google/cloud/storage/bucket_access_control.h"
#include "google/cloud/storage/internal/common_metadata.h"
#include "google/cloud/storage/internal/patch_builder.h"
#include "google/cloud/storage/lifecycle_rule.h"
#include "google/cloud/storage/object_access_control.h"
#include "google/cloud/storage/version.h"
#include "google/cloud/optional.h"
#include "absl/types/optional.h"
#include <map>
#include <tuple>
#include <utility>
 
namespace google {
namespace cloud {
namespace storage {
inline namespace STORAGE_CLIENT_NS {
namespace internal {
struct BucketMetadataParser;
class GrpcClient;
}  // namespace internal
 
struct BucketBilling {
  BucketBilling() = default;
  // NOLINTNEXTLINE(google-explicit-constructor)
  BucketBilling(bool v) : requester_pays(v) {}
 
  bool requester_pays{false};
};
 
inline bool operator==(BucketBilling const& lhs, BucketBilling const& rhs) {
  return lhs.requester_pays == rhs.requester_pays;
}
 
inline bool operator<(BucketBilling const& lhs, BucketBilling const& rhs) {
  return !lhs.requester_pays && rhs.requester_pays;
}
 
inline bool operator!=(BucketBilling const& lhs, BucketBilling const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(BucketBilling const& lhs, BucketBilling const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(BucketBilling const& lhs, BucketBilling const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(BucketBilling const& lhs, BucketBilling const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
struct CorsEntry {
  absl::optional<std::int64_t> max_age_seconds;
  std::vector<std::string> method;
  std::vector<std::string> origin;
  std::vector<std::string> response_header;
};
 
inline bool operator==(CorsEntry const& lhs, CorsEntry const& rhs) {
  return std::tie(lhs.max_age_seconds, lhs.method, lhs.origin,
                  lhs.response_header) == std::tie(rhs.max_age_seconds,
                                                   rhs.method, rhs.origin,
                                                   rhs.response_header);
}
 
inline bool operator<(CorsEntry const& lhs, CorsEntry const& rhs) {
  return std::tie(lhs.max_age_seconds, lhs.method, lhs.origin,
                  lhs.response_header) < std::tie(rhs.max_age_seconds,
                                                  rhs.method, rhs.origin,
                                                  rhs.response_header);
}
 
inline bool operator!=(CorsEntry const& lhs, CorsEntry const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(CorsEntry const& lhs, CorsEntry const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(CorsEntry const& lhs, CorsEntry const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(CorsEntry const& lhs, CorsEntry const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
std::ostream& operator<<(std::ostream& os, CorsEntry const& rhs);
 
struct UniformBucketLevelAccess {
  bool enabled;
  std::chrono::system_clock::time_point locked_time;
};
using BucketPolicyOnly = UniformBucketLevelAccess;
 
inline bool operator==(UniformBucketLevelAccess const& lhs,
                       UniformBucketLevelAccess const& rhs) {
  return std::tie(lhs.enabled, lhs.locked_time) ==
         std::tie(rhs.enabled, rhs.locked_time);
}
 
inline bool operator<(UniformBucketLevelAccess const& lhs,
                      UniformBucketLevelAccess const& rhs) {
  return std::tie(lhs.enabled, lhs.locked_time) <
         std::tie(rhs.enabled, rhs.locked_time);
}
 
inline bool operator!=(UniformBucketLevelAccess const& lhs,
                       UniformBucketLevelAccess const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(UniformBucketLevelAccess const& lhs,
                      UniformBucketLevelAccess const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(UniformBucketLevelAccess const& lhs,
                       UniformBucketLevelAccess const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(UniformBucketLevelAccess const& lhs,
                       UniformBucketLevelAccess const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
std::ostream& operator<<(std::ostream& os, UniformBucketLevelAccess const& rhs);
 
struct BucketIamConfiguration {
  absl::optional<UniformBucketLevelAccess> uniform_bucket_level_access;
};
 
inline bool operator==(BucketIamConfiguration const& lhs,
                       BucketIamConfiguration const& rhs) {
  return lhs.uniform_bucket_level_access == rhs.uniform_bucket_level_access;
}
 
inline bool operator<(BucketIamConfiguration const& lhs,
                      BucketIamConfiguration const& rhs) {
  return lhs.uniform_bucket_level_access < rhs.uniform_bucket_level_access;
}
 
inline bool operator!=(BucketIamConfiguration const& lhs,
                       BucketIamConfiguration const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(BucketIamConfiguration const& lhs,
                      BucketIamConfiguration const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(BucketIamConfiguration const& lhs,
                       BucketIamConfiguration const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(BucketIamConfiguration const& lhs,
                       BucketIamConfiguration const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
std::ostream& operator<<(std::ostream& os, BucketIamConfiguration const& rhs);
 
struct BucketLifecycle {
  std::vector<LifecycleRule> rule;
};
 
inline bool operator==(BucketLifecycle const& lhs, BucketLifecycle const& rhs) {
  return lhs.rule == rhs.rule;
}
 
inline bool operator<(BucketLifecycle const& lhs, BucketLifecycle const& rhs) {
  return lhs.rule < rhs.rule;
}
 
inline bool operator!=(BucketLifecycle const& lhs, BucketLifecycle const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(BucketLifecycle const& lhs, BucketLifecycle const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(BucketLifecycle const& lhs, BucketLifecycle const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(BucketLifecycle const& lhs, BucketLifecycle const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
struct BucketLogging {
  std::string log_bucket;
  std::string log_object_prefix;
};
 
inline bool operator==(BucketLogging const& lhs, BucketLogging const& rhs) {
  return std::tie(lhs.log_bucket, lhs.log_object_prefix) ==
         std::tie(rhs.log_bucket, rhs.log_object_prefix);
}
 
inline bool operator<(BucketLogging const& lhs, BucketLogging const& rhs) {
  return std::tie(lhs.log_bucket, lhs.log_object_prefix) <
         std::tie(rhs.log_bucket, rhs.log_object_prefix);
}
 
inline bool operator!=(BucketLogging const& lhs, BucketLogging const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(BucketLogging const& lhs, BucketLogging const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(BucketLogging const& lhs, BucketLogging const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(BucketLogging const& lhs, BucketLogging const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
std::ostream& operator<<(std::ostream& os, BucketLogging const& rhs);
 
struct BucketEncryption {
  std::string default_kms_key_name;
};
 
inline bool operator==(BucketEncryption const& lhs,
                       BucketEncryption const& rhs) {
  return lhs.default_kms_key_name == rhs.default_kms_key_name;
}
 
inline bool operator<(BucketEncryption const& lhs,
                      BucketEncryption const& rhs) {
  return lhs.default_kms_key_name < rhs.default_kms_key_name;
}
 
inline bool operator!=(BucketEncryption const& lhs,
                       BucketEncryption const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(BucketEncryption const& lhs,
                      BucketEncryption const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(BucketEncryption const& lhs,
                       BucketEncryption const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(BucketEncryption const& lhs,
                       BucketEncryption const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
struct BucketRetentionPolicy {
  std::chrono::seconds retention_period;
  std::chrono::system_clock::time_point effective_time;
  bool is_locked;
};
 
inline bool operator==(BucketRetentionPolicy const& lhs,
                       BucketRetentionPolicy const& rhs) {
  return std::tie(lhs.retention_period, lhs.effective_time, lhs.is_locked) ==
         std::tie(rhs.retention_period, rhs.effective_time, rhs.is_locked);
}
 
inline bool operator<(BucketRetentionPolicy const& lhs,
                      BucketRetentionPolicy const& rhs) {
  return std::tie(lhs.retention_period, lhs.effective_time, lhs.is_locked) <
         std::tie(rhs.retention_period, rhs.effective_time, rhs.is_locked);
}
 
inline bool operator!=(BucketRetentionPolicy const& lhs,
                       BucketRetentionPolicy const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(BucketRetentionPolicy const& lhs,
                      BucketRetentionPolicy const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(BucketRetentionPolicy const& lhs,
                       BucketRetentionPolicy const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(BucketRetentionPolicy const& lhs,
                       BucketRetentionPolicy const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
std::ostream& operator<<(std::ostream& os, BucketRetentionPolicy const& rhs);
 
struct BucketVersioning {
  BucketVersioning() = default;
  explicit BucketVersioning(bool flag) : enabled(flag) {}
 
  bool enabled{true};
};
 
inline bool operator==(BucketVersioning const& lhs,
                       BucketVersioning const& rhs) {
  return lhs.enabled == rhs.enabled;
}
 
inline bool operator<(BucketVersioning const& lhs,
                      BucketVersioning const& rhs) {
  return !lhs.enabled && rhs.enabled;
}
 
inline bool operator!=(BucketVersioning const& lhs,
                       BucketVersioning const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(BucketVersioning const& lhs,
                      BucketVersioning const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(BucketVersioning const& lhs,
                       BucketVersioning const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(BucketVersioning const& lhs,
                       BucketVersioning const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
struct BucketWebsite {
  std::string main_page_suffix;
  std::string not_found_page;
};
 
inline bool operator==(BucketWebsite const& lhs, BucketWebsite const& rhs) {
  return std::tie(lhs.main_page_suffix, lhs.not_found_page) ==
         std::tie(rhs.main_page_suffix, rhs.not_found_page);
}
 
inline bool operator<(BucketWebsite const& lhs, BucketWebsite const& rhs) {
  return std::tie(lhs.main_page_suffix, lhs.not_found_page) <
         std::tie(rhs.main_page_suffix, rhs.not_found_page);
}
 
inline bool operator!=(BucketWebsite const& lhs, BucketWebsite const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(BucketWebsite const& lhs, BucketWebsite const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(BucketWebsite const& lhs, BucketWebsite const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(BucketWebsite const& lhs, BucketWebsite const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
class BucketMetadata : private internal::CommonMetadata<BucketMetadata> {
 public:
  BucketMetadata() = default;
 
  // Please keep these in alphabetical order, that make it easier to verify we
  // have actually implemented all of them.
 
  std::vector<BucketAccessControl> const& acl() const { return acl_; }
  std::vector<BucketAccessControl>& mutable_acl() { return acl_; }
  BucketMetadata& set_acl(std::vector<BucketAccessControl> acl) {
    acl_ = std::move(acl);
    return *this;
  }
 
 
  bool has_billing() const { return billing_.has_value(); }
  BucketBilling const& billing() const { return *billing_; }
  absl::optional<BucketBilling> const& billing_as_optional() const {
    return billing_;
  }
  BucketMetadata& set_billing(BucketBilling const& v) {
    billing_ = v;
    return *this;
  }
  BucketMetadata& reset_billing() {
    billing_.reset();
    return *this;
  }
 
 
  bool default_event_based_hold() const { return default_event_based_hold_; }
  BucketMetadata& set_default_event_based_hold(bool v) {
    default_event_based_hold_ = v;
    return *this;
  }
 
 
  std::vector<CorsEntry> const& cors() const { return cors_; }
  std::vector<CorsEntry>& mutable_cors() { return cors_; }
  BucketMetadata& set_cors(std::vector<CorsEntry> cors) {
    cors_ = std::move(cors);
    return *this;
  }
 
 
  std::vector<ObjectAccessControl> const& default_acl() const {
    return default_acl_;
  }
  std::vector<ObjectAccessControl>& mutable_default_acl() {
    return default_acl_;
  }
  BucketMetadata& set_default_acl(std::vector<ObjectAccessControl> acl) {
    default_acl_ = std::move(acl);
    return *this;
  }
 
 
  bool has_encryption() const { return encryption_.has_value(); }
  BucketEncryption const& encryption() const { return *encryption_; }
  absl::optional<BucketEncryption> const& encryption_as_optional() const {
    return encryption_;
  }
  BucketMetadata& set_encryption(BucketEncryption v) {
    encryption_ = std::move(v);
    return *this;
  }
  BucketMetadata& reset_encryption() {
    encryption_.reset();
    return *this;
  }
 
  using CommonMetadata::etag;
 
 
  bool has_iam_configuration() const { return iam_configuration_.has_value(); }
  BucketIamConfiguration const& iam_configuration() const {
    return *iam_configuration_;
  }
  absl::optional<BucketIamConfiguration> const& iam_configuration_as_optional()
      const {
    return iam_configuration_;
  }
  BucketMetadata& set_iam_configuration(BucketIamConfiguration v) {
    iam_configuration_ = std::move(v);
    return *this;
  }
  BucketMetadata& reset_iam_configuration() {
    iam_configuration_.reset();
    return *this;
  }
 
  using CommonMetadata::id;
  using CommonMetadata::kind;
 
  bool has_label(std::string const& key) const {
    return labels_.end() != labels_.find(key);
  }
  std::string const& label(std::string const& key) const {
    return labels_.at(key);
  }
  BucketMetadata& delete_label(std::string const& key) {
    auto i = labels_.find(key);
    if (i == labels_.end()) {
      return *this;
    }
    labels_.erase(i);
    return *this;
  }
 
  BucketMetadata& upsert_label(std::string key, std::string value) {
    auto i = labels_.lower_bound(key);
    if (i == labels_.end() || i->first != key) {
      labels_.emplace_hint(i, std::move(key), std::move(value));
    } else {
      i->second = std::move(value);
    }
    return *this;
  }
 
  std::map<std::string, std::string> const& labels() const { return labels_; }
  std::map<std::string, std::string>& mutable_labels() { return labels_; }
 
 
  bool has_lifecycle() const { return lifecycle_.has_value(); }
  BucketLifecycle const& lifecycle() const { return *lifecycle_; }
  absl::optional<BucketLifecycle> const& lifecycle_as_optional() const {
    return lifecycle_;
  }
  BucketMetadata& set_lifecycle(BucketLifecycle v) {
    lifecycle_ = std::move(v);
    return *this;
  }
  BucketMetadata& reset_lifecycle() {
    lifecycle_.reset();
    return *this;
  }
 
  std::string const& location() const { return location_; }
  BucketMetadata& set_location(std::string v) {
    location_ = std::move(v);
    return *this;
  }
 
  std::string const& location_type() const { return location_type_; }
 
  bool has_logging() const { return logging_.has_value(); }
  BucketLogging const& logging() const { return *logging_; }
  absl::optional<BucketLogging> const& logging_as_optional() const {
    return logging_;
  }
  BucketMetadata& set_logging(BucketLogging v) {
    logging_ = std::move(v);
    return *this;
  }
  BucketMetadata& reset_logging() {
    logging_.reset();
    return *this;
  }
 
  using CommonMetadata::metageneration;
  using CommonMetadata::name;
  BucketMetadata& set_name(std::string v) {
    CommonMetadata::set_name(std::move(v));
    return *this;
  }
 
  using CommonMetadata::has_owner;
  using CommonMetadata::owner;
 
  std::int64_t const& project_number() const { return project_number_; }
 
  using CommonMetadata::self_link;
 
  bool has_retention_policy() const { return retention_policy_.has_value(); }
  BucketRetentionPolicy const& retention_policy() const {
    return *retention_policy_;
  }
  absl::optional<BucketRetentionPolicy> const& retention_policy_as_optional()
      const {
    return retention_policy_;
  }
  BucketMetadata& set_retention_policy(BucketRetentionPolicy v) {
    retention_policy_ = std::move(v);
    return *this;
  }
 
  BucketMetadata& set_retention_policy(std::chrono::seconds retention_period) {
    return set_retention_policy(BucketRetentionPolicy{
        retention_period, std::chrono::system_clock::time_point{}, false});
  }
 
  BucketMetadata& reset_retention_policy() {
    retention_policy_.reset();
    return *this;
  }
 
  using CommonMetadata::storage_class;
  BucketMetadata& set_storage_class(std::string v) {
    CommonMetadata::set_storage_class(std::move(v));
    return *this;
  }
 
  using CommonMetadata::time_created;
  using CommonMetadata::updated;
 
  absl::optional<BucketVersioning> const& versioning() const {
    return versioning_;
  }
  bool has_versioning() const { return versioning_.has_value(); }
  BucketMetadata& enable_versioning() {
    versioning_.emplace(BucketVersioning{true});
    return *this;
  }
  BucketMetadata& disable_versioning() {
    versioning_.emplace(BucketVersioning{false});
    return *this;
  }
  BucketMetadata& reset_versioning() {
    versioning_.reset();
    return *this;
  }
  BucketMetadata& set_versioning(absl::optional<BucketVersioning> v) {
    versioning_ = std::move(v);
    return *this;
  }
 
  bool has_website() const { return website_.has_value(); }
  BucketWebsite const& website() const { return *website_; }
  absl::optional<BucketWebsite> const& website_as_optional() const {
    return website_;
  }
  BucketMetadata& set_website(BucketWebsite v) {
    website_ = std::move(v);
    return *this;
  }
  BucketMetadata& reset_website() {
    website_.reset();
    return *this;
  }
 
  friend bool operator==(BucketMetadata const& lhs, BucketMetadata const& rhs);
  friend bool operator!=(BucketMetadata const& lhs, BucketMetadata const& rhs) {
    return !(lhs == rhs);
  }
 
 private:
  friend struct internal::BucketMetadataParser;
  friend class internal::GrpcClient;
 
  friend std::ostream& operator<<(std::ostream& os, BucketMetadata const& rhs);
  // Keep the fields in alphabetical order.
  std::vector<BucketAccessControl> acl_;
  absl::optional<BucketBilling> billing_;
  std::vector<CorsEntry> cors_;
  bool default_event_based_hold_ = false;
  std::vector<ObjectAccessControl> default_acl_;
  absl::optional<BucketEncryption> encryption_;
  absl::optional<BucketIamConfiguration> iam_configuration_;
  std::map<std::string, std::string> labels_;
  absl::optional<BucketLifecycle> lifecycle_;
  std::string location_;
  std::string location_type_;
  absl::optional<BucketLogging> logging_;
  std::int64_t project_number_ = 0;
  absl::optional<BucketRetentionPolicy> retention_policy_;
  absl::optional<BucketVersioning> versioning_;
  absl::optional<BucketWebsite> website_;
};
 
std::ostream& operator<<(std::ostream& os, BucketMetadata const& rhs);
 
class BucketMetadataPatchBuilder {
 public:
  BucketMetadataPatchBuilder() = default;
 
  std::string BuildPatch() const;
 
  BucketMetadataPatchBuilder& SetAcl(std::vector<BucketAccessControl> const& v);
 
  BucketMetadataPatchBuilder& ResetAcl();
 
  BucketMetadataPatchBuilder& SetBilling(BucketBilling const& v);
  BucketMetadataPatchBuilder& ResetBilling();
 
  BucketMetadataPatchBuilder& SetCors(std::vector<CorsEntry> const& v);
  BucketMetadataPatchBuilder& ResetCors();
 
  BucketMetadataPatchBuilder& SetDefaultEventBasedHold(bool v);
  BucketMetadataPatchBuilder& ResetDefaultEventBasedHold();
 
  BucketMetadataPatchBuilder& SetDefaultAcl(
      std::vector<ObjectAccessControl> const& v);
 
  BucketMetadataPatchBuilder& ResetDefaultAcl();
 
  BucketMetadataPatchBuilder& SetIamConfiguration(
      BucketIamConfiguration const& v);
  BucketMetadataPatchBuilder& ResetIamConfiguration();
 
  BucketMetadataPatchBuilder& SetEncryption(BucketEncryption const& v);
  BucketMetadataPatchBuilder& ResetEncryption();
 
  BucketMetadataPatchBuilder& SetLabel(std::string const& label,
                                       std::string const& value);
  BucketMetadataPatchBuilder& ResetLabel(std::string const& label);
  BucketMetadataPatchBuilder& ResetLabels();
 
  BucketMetadataPatchBuilder& SetLifecycle(BucketLifecycle const& v);
  BucketMetadataPatchBuilder& ResetLifecycle();
 
  BucketMetadataPatchBuilder& SetLogging(BucketLogging const& v);
  BucketMetadataPatchBuilder& ResetLogging();
 
  BucketMetadataPatchBuilder& SetName(std::string const& v);
  BucketMetadataPatchBuilder& ResetName();
 
  BucketMetadataPatchBuilder& SetRetentionPolicy(
      BucketRetentionPolicy const& v);
  BucketMetadataPatchBuilder& SetRetentionPolicy(
      std::chrono::seconds retention_period) {
    // This is the only parameter that the application can set, so make it easy
    // for them to set it.
    return SetRetentionPolicy(BucketRetentionPolicy{
        retention_period, std::chrono::system_clock::time_point{}, false});
  }
  BucketMetadataPatchBuilder& ResetRetentionPolicy();
 
  BucketMetadataPatchBuilder& SetStorageClass(std::string const& v);
  BucketMetadataPatchBuilder& ResetStorageClass();
 
  BucketMetadataPatchBuilder& SetVersioning(BucketVersioning const& v);
  BucketMetadataPatchBuilder& ResetVersioning();
 
  BucketMetadataPatchBuilder& SetWebsite(BucketWebsite const& v);
  BucketMetadataPatchBuilder& ResetWebsite();
 
 private:
  internal::PatchBuilder impl_;
  bool labels_subpatch_dirty_{false};
  internal::PatchBuilder labels_subpatch_;
};
 
}  // namespace STORAGE_CLIENT_NS
}  // namespace storage
}  // namespace cloud
}  // namespace google
 
#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_BUCKET_METADATA_H