Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://cloud.google.com/cpp/docs/reference/storage/latest/namespacegoogle_1_1cloud_1_1storage below:

Namespace google::cloud::storage (2.42.0-rc) | C++ Client Libraries

Contains all the Google Cloud Storage C++ client APIs.

A IdempotencyPolicy that always retries all requests.

Wraps the bucketAccessControl resource in Google Cloud Storage.

Prepares a patch for a BucketAccessControl resource.

Represents a Google Cloud Storage Bucket Metadata object.

Prepares a patch for the Bucket resource.

Describes the configuration for low-level connection features.

The Google Cloud Storage (GCS) Client.

Describes the configuration for a storage::Client object.

An option to inject custom headers into the request.

Report checksum mismatches as exceptions.

Represents the metadata for a Google Cloud Storage HmacKeyResource.

Define the interface for the idempotency policy.

Defines objects to read, create, and modify Object Lifecycle Rules.

A retry policy based on counting errors.

A retry policy based on elapsed time.

A parameter type indicating the maximum number of streams to ParallelUploadFile.

A parameter type indicating the minimum stream size to ParallelUploadFile.

Represents a google::type::Expr.

Represents a Binding which associates a member with a particular role which can be used for Identity and Access management for Cloud Platform Resources.

Represent the result of a GetIamPolicy or SetIamPolicy request.

Represents the metadata for a Google Cloud Storage Notification resource.

Wraps the objectAccessControl resource in Google Cloud Storage.

Prepares a patch for an ObjectAccessControl resource.

Represents the metadata for a Google Cloud Storage Object.

Prepares a patch for the Bucket resource.

Defines a std::basic_istream<char> to read from a GCS Object.

Complete long running object rewrite operations.

Defines a std::basic_ostream<char> to write to a GCS object.

Define a condition for a policy document.

The base class for the Storage library retry policies.

Represents the metadata for a Google Cloud Storage service account.

A IdempotencyPolicy that only retries strictly idempotent requests.

Modify the accepted encodings.

Add a extension header to a POST policy.

Add a extension header to a signed URL.

Add a extension header to a signed URL.

Control whether upload streams auto-finalize on destruction.

Set the backoff policy for a GCS client.

The autoclass configuration for a Bucket.

The billing configuration for a Bucket.

Use domain-named bucket in a V4 signed URL.

Configuration for Custom Dual Regions.

Describes the default customer managed encryption key for a bucket.

Configuration for a bucket's hierarchical namespace feature.

The IAM configuration for a Bucket.

The Object Lifecycle configuration for a Bucket.

The Logging configuration for a Bucket.

The soft delete policy for a bucket.

The retention policy for a bucket.

The soft delete policy for a bucket.

The versioning configuration for a Bucket.

The website configuration for a Bucket.

Defines one of the source objects for a compose operation.

Set the maximum connection pool size.

Sets the contentEncoding option for object uploads.

Set the MIME content type of an object.

Applicable only for buckets the don't have uniform bucket-level access enabled.

An entry in the CORS list.

Provide a pre-computed CRC32C checksum value.

A simple representation for the customerEncryption field.

Included deleted HMAC keys in list requests.

Returns results in a directory-like mode.

Configure the Customer-Managed Encryption Key (CMEK) for an rewrite.

Set the ACL to a predefined value when copying Objects.

Disable CRC32C checksum computations.

Disable or enable MD5 Hashing computations.

Control the formatted I/O download buffer.

The minimum accepted bytes/second download rate.

Sets the download stall timeout.

Disables automatic OpenSSL sigpipe handler.

Disables automatic OpenSSL locking.

Set this parameter to true to create buckets with object retention enabled.

An optional parameter to set the Customer-Supplied Encryption key.

A simple wrapper for the encryption key attributes.

Filter results to objects whose names are lexicographically before EndOffset.

Define the expiration time for a signed URL.

Defines the fields query parameter.

Set the version of an object to operate on.

Configure the IAM endpoint for the GCS client library.

Set the idempotency policy for a GCS client.

A pre-condition: the request succeeds only if the object generation matches.

A pre-condition: the request succeeds unless the object generation matches.

A pre-condition: apply this operation only if the HTTP Entity Tag matches.

A pre-condition: the request succeeds if the metadata generation matches.

A pre-condition: the request succeeds unless the metadata generation matches.

A pre-condition: apply this operation only if the HTTP Entity Tag does not match.

A pre-condition: the request succeeds if the source object generation matches.

A pre-condition: the request succeeds unless the source object generation matches.

A pre-condition: the request succeeds if the source object metadata generation matches.

A pre-condition: the request succeeds unless the source object metadata generation matches.

Set this parameter to true to include folders in the Client::ListObjectsAndPrefixes() calls.

If true, objects that end in exactly one instance of delimiter have their metadata included in items[] in addition to the relevant part of the object name appearing in prefixes[].

Configure the Customer-Managed Encryption Key (CMEK) for an upload.

Implement a wrapper for Lifecycle Rules actions.

Implement a wrapper for Lifecycle Conditions.

Restrict list operations to entries matching a glob pattern.

Limit the number of bytes rewritten in a Objects: rewrite step.

Control the maximum socket receive buffer.

Control the maximum socket send buffer.

Defines the threshold to switch from simple to resumable uploads for files.

Limit the number of results per page when listing Buckets and Objects.

Provide a pre-computed MD5 hash value.

Configure oauth2::Credentials for the GCS client library.

Specifies the retention parameters of an object.

Override the default project.

Set this parameter to true to override the current object's retention.

A simple wrapper for the owner field in object and bucket metadata.

Define a policy document.

Define a policy document result.

Define a policy document V4.

Define a policy document result V4.

Set the ACL to predefined values when creating Buckets or Objects.

Set the default object ACL to a predefined value in a Bucket.

Restrict list operations to entries starting with this value.

Set the Google Cloud Platform project id.

Controls what metadata fields are included in the response.

Represents the projectTeam field in *AccessControls.

Sets the user for this operation for quota enforcement purposes.

Download all the data from the GCS object starting at the given offset.

Read last N bytes from the GCS object.

Request only a portion of the GCS object in a ReadObject operation.

Controls the IAM policy version returned by IAM queries.

Configure the REST endpoint for the GCS client library.

Set the retry policy for a GCS client.

Represents the status of a rewrite operation.

Use the specified scheme (e.g. "http") in a V4 signed URL.

Only list HMAC keys belonging to a specific Service Account.

Define the duration for a V4 signed URL.

Define the timestamp duration for a V4 signed URL.

Specify the service account used to sign a blob.

Specify the sequence of delegates used to sign a blob.

Set this parameter to true to include soft-deleted object in Client::ListObjects() and Client::GetObjectMetadata() calls.

An optional parameter to set the Customer-Supplied Encryption key for rewrite source object.

Set the generation for the source object in copy operations.

Filter results to objects whose names are lexicographically equal to or after StartOffset.

Specify a sub-resource in a signed URL.

The minimum accepted bytes/second transfer rate.

Sets the transfer stall timeout.

Configure if only the IAM policies are used for access control.

Set the buffer size for a stream created in Client::WriteObject().

Control the formatted I/O upload buffer.

Provide an expected final length of an uploaded object.

Upload the local file to GCS server starting at the given offset.

The maximum length of the local file to upload to GCS server.

Request a resumable upload, restoring a previous session if necessary.

Sets the user IP on an operation for quota enforcement purposes.

Set the project used for billing in "requester pays" Buckets.

Control if all versions of an object should be included when listing objects.

Indicate that the bucket should be a part of hostname in the URL.

A request option to define the object metadata attributes.

Public Access Prevention helper functions

Public Access Prevention helper functions

Public Access Prevention helper functions

Well-known values for the project_team().team field..

The following functions are handy to avoid common typos in the team names.

We use functions instead of enums because enums are not backwards compatible and are brittle to changes in the server-side.

Well-known values for the project_team().team field..

The following functions are handy to avoid common typos in the team names.

We use functions instead of enums because enums are not backwards compatible and are brittle to changes in the server-side.

Well-known values for the project_team().team field..

The following functions are handy to avoid common typos in the team names.

We use functions instead of enums because enums are not backwards compatible and are brittle to changes in the server-side.

Configure a stream to automatically finalize an upload on destruction.

Configure a stream to leave uploads pending (not finalized) on destruction.

A helper function to avoid typos in the RPO configuration.

A helper function to avoid typos in the RPO configuration.

Create a random prefix for object names.

This is useful for operations which require a unique prefix for temporary files.

This is a helper function and it doesn't communicate with GCS, so there is a very small chance that names generated this way aren't unique. The chance should be small enough to fit any error budget.

Given the same prefix, the randomly generated names will have the same length.

the prefix of the prefix to be created.

the random prefix name

Delete objects whose names match a given prefix.

the client on which to perform the operation.

the name of the bucket that will contain the object.

the prefix of the objects to be deleted.

a list of optional query parameters and/or request headers. Valid types for this operation include QuotaUser, UserIp, UserProject and Versions.

Compose existing objects into a new object in the same bucket.

Contrary to Client::ComposeObject, this function doesn't have a limit on the number of source objects.

The implementation may need to perform multiple Client::ComposeObject calls to create intermediate, temporary objects which are then further composed. Due to the lack of atomicity of this series of operations, stray temporary objects might be left over if there are transient failures. In order to allow the user to easily control for such situations, the user is expected to provide a unique prefix parameter, which will become the prefix of all the temporary objects created by this function. Once this function finishes, the user may safely remove all objects with the provided prefix (e.g. via DeleteByPrefix()). We recommend using CreateRandomPrefixName() for selecting a random prefix within a bucket.

This operation is not idempotent. While each request performed by this function is retried based on the client policies, the operation itself stops on the first request that fails.

  namespace gcs = ::google::cloud::storage;
  using ::google::cloud::StatusOr;
  [](gcs::Client client, std::string const& bucket_name,
     std::string const& destination_object_name,
     std::vector<gcs::ComposeSourceObject> const& compose_objects) {
    std::string prefix = gcs::CreateRandomPrefixName(".tmpfiles");
    StatusOr<gcs::ObjectMetadata> composed_object =
        ComposeMany(client, bucket_name, compose_objects, prefix,
                    destination_object_name, false);
    // If this is an effect of some transient unavailability, stray temporary
    // might be left over. You can use `DeleteByPrefix()` with `prefix` as
    // argument to delete them.
    if (!composed_object) throw std::move(composed_object).status();

    std::cout << "Composed new object " << composed_object->name()
              << " in bucket " << composed_object->bucket()
              << "\nFull metadata: " << *composed_object << "\n";
  }

the client on which to perform the operations needed by this function

the name of the bucket used for source object and destination object.

objects used to compose destination_object_name.

prefix for temporary objects created by this function; there should not be any objects with this prefix; in order to avoid race conditions, this function will create an object with this name

the composed object name.

if the composition succeeds but cleanup of temporary objects fails, depending on this parameter either a success will be returned (true) or the relevant cleanup error (false)

a list of optional query parameters and/or request headers. Valid types for this operation include DestinationPredefinedAcl, EncryptionKey, IfGenerationMatch, IfMetagenerationMatchKmsKeyName, QuotaUser, UserIp, UserProject and WithObjectMetadata.

Create a google::cloud::storage::Client object configured to use gRPC.

void GrpcReadWrite(std::string const& bucket_name) {
  namespace gcs = ::google::cloud::storage;
  auto constexpr kText = R"""(Hello World!)""";

  auto client = gcs::MakeGrpcClient();

  auto object = client.InsertObject(bucket_name, "lorem.txt", kText);
  if (!object) throw std::move(object).status();

  auto input = client.ReadObject(bucket_name, "lorem.txt",
                                 gcs::Generation(object->generation()));
  std::string const actual(std::istreambuf_iterator<char>{input}, {});
  if (input.bad()) throw google::cloud::Status(input.status());
  std::cout << "The contents read back are:\n"
            << actual
            << "\nThe received checksums are: " << input.received_hash()
            << "\nThe computed checksums are: " << input.computed_hash()
            << "\nThe original hashes    are: crc32c=" << object->crc32c()
            << ",md5=" << object->md5_hash() << "\n";
}

the configuration parameters for the Client.

Compute the MD5 Hash of a buffer in the format preferred by GCS.

Compute the MD5 Hash of a buffer in the format preferred by GCS.

Compute the MD5 Hash of a buffer in the format preferred by GCS.

Enable MD5 hashes in upload and download operations.

Use this function where the option DisableMD5Hash is expected to enable MD5 hashes.

Compute the CRC32C checksum of a buffer in the format preferred by GCS.

Compute the CRC32C checksum of a buffer in the format preferred by GCS.

Compute the CRC32C checksum of a buffer in the format preferred by GCS.

A helper function to avoid typos in the ObjectRetention configuration.

A helper function to avoid typos in the ObjectRetention configuration.

Perform a parallel upload of a given file.

You can affect how many shards will be created by using the MaxStreams and MinStreamSize options.

This operation is not idempotent. While each request performed by this function is retried based on the client policies, the operation itself stops on the first request that fails.

  namespace gcs = ::google::cloud::storage;
  using ::google::cloud::StatusOr;
  [](gcs::Client client, std::string const& file_name,
     std::string const& bucket_name, std::string const& object_name) {
    // Pick a unique random prefix for the temporary objects created by the
    // parallel upload.
    auto prefix = gcs::CreateRandomPrefixName("");

    auto metadata = gcs::ParallelUploadFile(
        std::move(client), file_name, bucket_name, object_name, prefix, false);
    if (!metadata) throw std::move(metadata).status();

    std::cout << "Uploaded " << file_name << " to object " << metadata->name()
              << " in bucket " << metadata->bucket()
              << "\nFull metadata: " << *metadata << "\n";
  }

the client on which to perform the operation.

the path to the file to be uploaded

the name of the bucket that will contain the object.

the uploaded object name.

the prefix with which temporary objects will be created.

treat failures to cleanup the temporary objects as not fatal.

a list of optional query parameters and/or request headers. Valid types for this operation include DestinationPredefinedAcl, EncryptionKey, IfGenerationMatch, IfMetagenerationMatch, KmsKeyName, MaxStreams,MinStreamSize,QuotaUser,UserIp,UserProject,WithObjectMetadata,UseResumableUploadSession`.

the metadata of the object created by the upload.

Format the current date in the format expected by a POST form.

Create a UseResumableUploadSession option that restores previous sessions.

Create a UseResumableUploadSession option that requests new sessions.

Returns the Google Cloud Storage C++ Client major version.

Returns the Google Cloud Storage C++ Client minor version.

Returns the Google Cloud Storage C++ Client patch version.

Returns the Google Cloud Storage C++ Client pre-release version.

Returns a single integer representing the Major/Minor/Patch version.

Returns the version as a string, in MAJOR.MINOR.PATCH[-PRE][+gitrev] format.

Returns the value for x-goog-api-client header.

Formats a (potentially binary) encryption key in the format required by the Google Cloud Storage API.

a binary key, must have exactly 32 bytes.

Formats an encryption key in base64 format to the data structure required by the Google Cloud Storage API.

a base64-encoded key, must have exactly 32 bytes when decoded.

Creates an encryption key parameter from a pseudo-random number generator.

  // Create a pseudo-random number generator (PRNG), this is included for
  // demonstration purposes only. You should consult your security team about
  // best practices to initialize PRNG. In particular, you should verify that
  // the C++ library and operating system provide enough entropy to meet the
  // security policies in your organization.

  // Use the Mersenne-Twister Engine in this example:
  //   https://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine
  // Any C++ PRNG can be used below, the choice is arbitrary.
  using GeneratorType = std::mt19937_64;

  // Create the default random device to fetch entropy.
  std::random_device rd;

  // Compute how much entropy we need to initialize the GeneratorType:
  constexpr auto kRequiredEntropyWords =
      GeneratorType::state_size *
      (GeneratorType::word_size / std::numeric_limits<unsigned int>::digits);

  // Capture the entropy bits into a vector.
  std::vector<std::uint64_t> entropy(kRequiredEntropyWords);
  std::generate(entropy.begin(), entropy.end(), [&rd] { return rd(); });

  // Create the PRNG with the fetched entropy.
  std::seed_seq seed(entropy.begin(), entropy.end());

  // initialized with enough entropy such that the encryption keys are not
  // predictable. Note that the default constructor for all the generators in
  // the C++ standard library produce predictable keys.
  std::mt19937_64 gen(seed);

  namespace gcs = ::google::cloud::storage;
  gcs::EncryptionKeyData data = gcs::CreateKeyFromGenerator(gen);

  std::cout << "Base64 encoded key = " << data.key << "\n"
            << "Base64 encoded SHA256 of key = " << data.sha256 << "\n";

https://en.cppreference.com/w/cpp/numeric/random for a general overview of C++ pseudo-random number support.

https://en.cppreference.com/w/cpp/numeric/random/UniformRandomBitGenerator for a more detailed overview of the requirements for generators.

the pseudo-random number generator.

the pseudo-random number generator type, it must meet the UniformRandomBitGenerator requirements.

Alias Of: UniformBucketLevelAccess

Alias Of: std::multimap< std::string, std::string >

Represents the headers returned in a streaming upload or download operation.

Alias Of: google::cloud::internal::PaginationRange< BucketMetadata >

Alias Of: ListBucketsReader::iterator

Alias Of: google::cloud::internal::PaginationRange< HmacKeyMetadata >

A range to paginate over the HmacKeys for a project.

Alias Of: ListHmacKeysReader::iterator

Alias Of: absl::variant< ObjectMetadata, std::string >

Alias Of: google::cloud::internal::PaginationRange< ObjectOrPrefix >

Alias Of: ListObjectsAndPrefixesReader::iterator

Alias Of: google::cloud::internal::PaginationRange< ObjectMetadata >

Alias Of: ListObjectsReader::iterator

Alias Of: ::google::cloud::OptionList< RestEndpointOption, IamEndpointOption, Oauth2CredentialsOption, ProjectIdOption, ProjectIdOption, ConnectionPoolSizeOption, DownloadBufferSizeOption, UploadBufferSizeOption, EnableCurlSslLockingOption, EnableCurlSigpipeHandlerOption, MaximumCurlSocketRecvSizeOption, MaximumCurlSocketSendSizeOption, TransferStallTimeoutOption, RetryPolicyOption, BackoffPolicyOption, IdempotencyPolicyOption, CARootsFilePathOption, storage_experimental::HttpVersionOption >

The complete list of options accepted by storage::Client.

Alias Of: ::google::cloud::internal::BackoffPolicy

The backoff policy base class.

Alias Of: ::google::cloud::internal::ExponentialBackoffPolicy

Implement truncated exponential backoff with randomization.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4