int PutObjectDemo(Client& client,const std::string& bucketName, const std::string objectKey){
    // Get the file data flow
    FileInputStream inputStream("/path/to/test.zip"); // bcesdk/util/util.h
	int ret = 0;
    // Upload objects with the file name as parameter
    ret = client.upload_file(bucketName, objectKey, "/path/to/test.zip");
    // Upload objects in the form of data stream
    ret = client.upload_file(bucketName, objectKey, inputStream);
    // Upload objects in the form of file descriptor    
    fd_t fd = open("/path/to/test.zip", O_RDWR, 0666);//Under linux, fd_t is defined in common.h
    ret = client.upload_file(bucketName, objectKey, fd);
    // Upload objects in the form of string
    std::string data = "this is data";
	ret = client.put_object(bucketName, objectKey, data);
    return ret;
}

int PutLargeObjectDemo(Client& client,const std::string& bucketName, const std::string objectKey){
    std::string fileName = "/path/to/test.zip"
    return client.upload_super_file(bucketName, objectKey, fileName);// The third parameter can be also the fd_t form.
}

...
// Initialize meta
ObjectMetaData meta;

//Set the ContentType
meta.set_content_type("application/json");

// Set cache-control
meta.set_cache_control("no-cache");

//Set x-bce-storage-class
meta.set_storage_class("STANDARD");

ret = client.upload_file(bucketName, objectKey, content, meta);
...

// Set the value of custom metadata name to my-data.
meta.set_user_meta("name", "my-data");
    
//Upload Object
ret = client.upload_file(bucketName, objectKey, file_name, meta);

// Initialize BosClient
Client client = ...;

// Create a CopyObjectRequest object.
CopyObjectRequest copyObjectRequest(destBucketName, destKey, srcBucketName, srcKey);
CopyObjectResponse copyObjectResponse；

// Set a new metadata.
StringMap& userMetadata = *(meta.mutable_user_meta());//StringMap == map<string, string>
userMetadata.clear();
userMetadata["<user-meta-key>"] = "<user-meta-value>";

copyObjectRequest.set_meta(&meta, false);// If the second parameter (is_own) is true, delete the meta when it is destructed by copyObjectRequest.
//copy-source-if-match
copyObjectRequest.set_if_match("111111111183bf192b57a4afc76fa632");
//copy-source-if-none-match
copyObjectRequest.set_if_none_match("111111111183bf192b57a4afc76fa632");
        
std::string gmtDate = TimeUtil::now_gmttime();//The current time in the GMT format 

//copy-source-if-modified-since
copyObjectRequest.set_if_modified_since(gmtDate);

//copy-source-if-unmodified-since
copyObjectRequest.set_if_unmodified_since(gmtDate);

// Copy the Object
client.copy_object(copyObjectRequest， copyObjectResponse；);

std::cout << "ETag: " << copyObjectResponse.etag() << " LastModified: " <<      copyObjectResponse.last_modified() << std::endl;

void print_common_response(BceResponse &result) {
    printf("status:%d\n", result.status_code());
    if (result.is_ok()) {
        printf("request-id:%s\n", result.request_id().c_str());
        printf("debug-id:%s\n", result.debug_id().c_str());
    }
    if (result.is_fail()) {
        printf("error-message:%s\n", result.error().message().c_str());
    }
}
int putObjectStorageClass(){
    std::string filename = "file.txt";  
    FileInputStream file(filename); 
    PutObjectRequest request(bucket, object, &file); 
    request.mutable_meta()->set_storage_class("STANDARD_IA");
    PutObjectResponse result;
    client.put_object(request, &result);
    print_common_response(result);  
    printf("etag: %s\n", result.etag().c_str());
}

int AppendObjectDemo(Client& client,const std::string& bucketName, const std::string& objectKey) {

    // Get the data stream
    FileInputStream inputStream("/path/to/test.zip");

    // Upload objects in the form of the data stream
    AppendObjectRequest appendObjectFromInputStreamRequest(bucketName, objectKey, &inputStream);
    AppendObjectResponse appendObjectFromInputStreamResponse;
    int ret = client.append_object(appendObjectFromInputStreamRequest, &appendObjectFromInputStreamResponse);
   
    // Upload the Object in the form of string
    std::string data = "this is data";
    AppendObjectRequest appendObjecFromStringtRequest(bucketName, objectKey, data);
    AppendObjectResponse appendObjectFromStringResponse; 
    
    ret = client.appendObject(appendObjecFromStringtRequest, &appendObjectFromStringResponse);

    // Print ETag
    std::cout << appendObjectFromInputStreamResponse.etag() << std::endl;
    // Print NextAppendOffset
    std::cout << appendObjectFromInputStreamResponse.next_append_offset() << std::endl;


    // Example of AppendUpload, for which you need to add the location of next AppendObject in the request.
    long long nextAppendOffset = appendObjectFromInputStreamResponse.next_append_offset();
    AppendObjectRequest appendObjectFromStringRequest(bucketName,objectKey,data);
    appendObjectFromStringRequest.set_offset(nextAppendOffset);
    AppendObjectResponse appendObjectFromStringResponse;
    ret = client.append_object(appendObjectFromStringRequest, &appendObjectFromStringResponse);
    return ret;
}

// Start Multipart Upload
InitMultiUploadRequest initMultiUploadRequest(bucketName, objectKey);
InitMultiUploadResponse initMultiUploadResponse;
int ret = client.init_multipart_upload(initMultiUploadRequest, &initMultiUploadResponse);
//Exception handling
...    
// Print UploadId
std::cout << "UploadId: " << initMultiUploadResponse.upload_id() << std::endl;

void putMultiUploadStorageClass(){
    ObjectMetaData meta;
    meta.set_storage_class("STANDARD_IA");
    InitMultiUploadRequest initMultiUploadRequest(bucketName, objectKey);
    InitMultiUploadResponse initMultiUploadResponse;
    initMultiUploadRequest.set_meta(&meta);
    client.init_multipart_upload(initMultiUploadRequest, &initMultiUploadResponse);
}

void putMultiUploadStorageClass(){
    ObjectMetaData meta;
    meta.set_storage_class("COLD)");
    InitMultiUploadRequest initMultiUploadRequest(bucketName, objectKey);
    InitMultiUploadResponse initMultiUploadResponse;
    initMultiUploadRequest.set_meta(&meta);
    client.init_multipart_upload(initMultiUploadRequest, &initMultiUploadResponse);
}

// Set each part to 5 MB.
long partSize = 1024 * 1024 * 5L;

std::string partFileName = "/path/to/file.zip";
FileInputStream file(partFileName);
// Compute the number of multiparts.
int partCount = static_cast<int>(file.get_size() / partSize);
if (file.get_size() % partSize != 0){
    partCount++;
}

// Create a vector to save the ETag and part_number of each part after the multipart upload.
std::vectorvector<part_t> partEtags;

for(int i = 0; i < partCount; i++){
    // Redirect to the beginning of each part.
    long skipBytes = partSize * i;

    // Compute the size of each part.
    long size = partSize < file.get_size() - skipBytes ?
            partSize : file.get_size() - skipBytes;
    // Set the file read range [skipBytes, skipBytes+size).
    file.seek(skipBytes);
????file.set_size(file.get_size()- size);
    
    // Create UploadPartRequest and upload parts.
    UploadPartRequest uploadPartRequest(bucketName, objectKey, file, i + 1, initMultiUploadResponse.upload_id());
   
    UploadPartResponse uploadPartResponse;
    int ret = client.upload_part(uploadPartRequest, &uploadPartResponse);
    // Save the returned PartETag to the List.
    part_t partInfo;
    partInfo.part_number = i+1;
    partInfo.etag = uploadPartResponse.etag();
    partEtags.push_back(partInfo);
}

CompleteMultipartUploadRequest completeMultipartUploadRequest(bucketName, objectKey, initMultiUploadResponse.upload_id());

// Add the part information, i.e., part merging order.
for (part_t partInfo : partEtags) {
    completeMultipartUploadRequest.add_part(partInfo.part_number, partInfo.etag);
}
    
// Complete the multipart upload.
CompleteMultipartUploadResponse completeMultipartUploadResponse;
int ret = client.complete_multipart_upload(completeMultipartUploadRequest, &completeMultipartUploadResponse);
    
// Print the ETag of objects.
std::cout << completeMultipartUploadResponse.etag() << std::endl;

AbortMultipartUploadRequest abortMultipartUploadRequest(bucketName, objectKey, uploadId);
AbortMultipartUploadResponse abortMultipartUploadResponse;
// Cancel the multipart upload
int ret = client.abort_multipart_upload(abortMultipartUploadRequest, &abortMultipartUploadResponse);

ListMultipartUploadsRequest listMultipartUploadsRequest(bucketName);
ListMultipartUploadsResponse listMultipartUploadsResponse;
// Get all multipart upload events in the bucket.
int ret = client.list_multipart_uploads(listMultipartUploadsRequest, &
listMultipartUploadsResponse);

if (ret != 0) {
    return ret;
}    

// Go through all multipart upload events.
for (const MultipartUploadSummary& multipartUpload : listMultipartUploadsResponse.uploads()) {
    std::cout << "Key: " << multipartUpload.key << 
        " UploadId: " << multipartUpload.upload_id << std::endl;
}

ListPartsRequest listPartsRequest(bucketName, objectKey, uploadId);
    
// Get the information on all parts uploaded.
ListPartsResponse listPartsResponse;
int ret = client.list_parts(listPartsRequest, &listPartsResponse);

if (ret != 0) {
    return ret;
}    

// Go through all parts.
for (consr PartSummary& part : listPartsResponse.parts()) {
    std::cout << "PartNumber: " << part.part_number << " ETag: " << part.etag;
}

public void listPartsStorageClass(){
    ListPartsRequest listPartsRequest(bucketName, objectKey, uploadId);
    
    // Get the information on all parts uploaded.
    ListPartsResponse listPartsResponse;
    int ret = client.list_parts(listPartsRequest, &listPartsResponse);

    if (ret != 0) {
        return ret;
    }    
    std::string storageClass = listPartsResponse.storage_class();
}

void getObject(Client& client, const std::string& bucketName, const std::string& objectKey) {
    
    // Get the file output stream.
    FileOutputStream outStream("test.txt");

    // Method 1: Get it through the request and response.
    //Initialize the request
    GetObjectRequest getObjectRequest(bucketName, objectKey);
    // Use outStream as the output object.
    GetObjectResponse getObjectResponse(&outStream);
    int ret = client.get_object(getObjectRequest, &getObjectResponse);

    // Method 2: Write the object to the outStream file stream through the convenient interface.
    ret = client.download_file(bucketName, objectKey, outStream);
    ...
}

// Download objects to the file.
std::string localFileName = "test.txt";
ObjectMetadata objectMetadata;

// Set the read range of objects.
int64_t start = 0;
int64_t length = 100;
//Download the Object
int ret = client.download_file(bucketName, objectKey, localFileName, start, length, &objectMetadata); // Save the object to test.txt and return objectMetadata.
...

std::string inMemoryData;
// Method 1: Get the object through the request and response.
GetObjectRequest getObjectRequest(bucketName, objectKey);
//Use inMemoryData as the output object
GetObjectResponse getObjectResponse(&inMemoryData);
int ret = client.get_object(getObjectRequest, &getObjectResponse);

if (ret != 0) {
    return ret;
}

//Method 2, get the object through a convenient interface
ret = client.get_object(bucketName, objectKey, &inMemoryData);
// Print out
std::cout << inMemoryData << std::endl;

GetObjectRequest getObjectRequest(bucketName, objectKey);
// Initialize the file output stream.
FileOutputStream outStream("test.txt");
GetObjectResponse getObjectResponse(&outStream);
// Set the byte data of the download range [0, 100].
getObjectRequest.set_range(0, 100);
int ret = client.get_object(getObjectRequest, &getObjectResponse);

if (ret != 0) {
    return ret;
}
return 0;

int getObjectStorageClass(){
    HeadObjectRequest request(bucketName, objectKey);
    HeadObjectResponse response;
    int ret = client.head_object(request, &response);
    if (ret != 0) {
        return ret;
    }
    ObjectMetadata& meta = response.meta();
    std::string storageClass = meta.storage_class();
    std::cout << storageClass << std::endl;
    return 0;
}

// Change the standard storage to the infrequent access
CopyObjectRequest copyObjectRequest(destBucketName, destKey, srcBucketName, srcKey);
copyObjectRequest.mutable_meta()->set_storage_class("STANDARD_IA");
CopyObjectResponse copyObjectResponse;
int ret = client.copy_object(copyObjectRequest, &copyObjectResponse);

// Change the infrequent access to the cold storage
CopyObjectRequest copyObjectRequest(destBucketName, destKey, srcBucketName, srcKey);
copyObjectRequest.mutable_meta()->set_storage_class("COLD");
CopyObjectResponse copyObjectResponse;
ret = client.copy_object(copyObjectRequest, &copyObjectResponse);

std::string generatePresignedUrl(Client& client, const std::string& bucketName, const std::string& objectKey, int expirationInSeconds) {

   // Specify the bucket name of the object to be got by users, object name, and effective duration of the URL.   
   return  client.generate_url(bucketName, objectKey, expirationInSeconds);
}

void listObjects(Client& client, const std::string bucketName) {
    ListObjectsRequest listObjectsRequest(bucketName);
    // Get all object information in the specified bucket.
    ListObjectsResponse listObjectsResponse;
    int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);

    if (ret != 0) return;
    if (listObjectResponse.is_fail()) {
        return;
    }
    // Go through all objects
    for (const ObjectSummary& objectSummary : listObjectsResponse.contents()) {
        std::cout << "ObjectKey: " << objectSummary.key << std::endl;
    }
}

// Specify that the maximum number of objects returned is 500.
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_max_keys(500);
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//Response exception handling
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << "ObjectKey: " << objectSummary.key << std::endl;
}

// Specify to return the objects with prefix Test.
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_prefix("test");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//Response exceptional handling
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << "ObjectKey: " << objectSummary.key << std::endl;
}

// Users can define that an object is not included and it returns after this object.
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_marker("object");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//Response exceptional handling
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << "ObjectKey: " << objectSummary.key << std::endl;
}

// Users can set and there are up to 500 records per page.
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_max_keys(500);
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//Response exception handling

bool isTruncated = true;
while (isTruncated) {
    ListObjectsResponse listObjectsResponse;
    client.list_objects(listObjectsRequest, &listObjectsResponse);
    isTruncated = listObjectsResponse.is_truncated();
    if (listObjectsResponse.next_marker() != "") {
        listObjectsRequest.set_marker(listObjectsResponse.next_marker());
    }
}

// Users can set up to 500 records per page and get them after a specific object.
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_max_keys(500);
listObjectsRequest.set_marker("object");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;

bool isTruncated = true;
while (isTruncated) {
    ListObjectsResponse listObjectsResponse;
    client.list_objects(listObjectsRequest, &listObjectsResponse);
    isTruncated = listObjectsResponse.is_truncated();
    if (listObjectsResponse.next_marker() != "") {
        listObjectsRequest.set_marker(listObjectsResponse.next_marker());
    }
}

// Users can set the paging to get objects with specified prefix. There are up to 500 records per page.
ListObjectsRequest listObjectsRequest("bucketName");
listObjectsRequest.set_max_keys(500);
listObjectsRequest.set_prefix("object");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;

bool isTruncated = true;
while (isTruncated) {
    ListObjectsResponse listObjectsResponse;
    client.list_objects(listObjectsRequest, &listObjectsResponse);
    isTruncated = listObjectsResponse.is_truncated();
    if (listObjectsResponse.next_marker() != "") {
        listObjectsRequest.set_marker(listObjectsResponse.next_marker());
    }
}

// Construct ListObjectsRequest.
ListObjectsRequest listObjectsRequest("bucketName");
// List all files in the fun directory recursively.
listObjectsRequest.set_prefix("fun/");
ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;
...//Response exception handling
std::cout << "ObjectKeys:" << std::endl;
// Go throught all objects
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << objectSummary.key << std::endl;
}

ObjectKeys:
fun/
fun/movie/001.avi
fun/movie/007.avi
fun/test.jpg

// Construct ListObjectsRequest.
ListObjectsRequest listObjectsRequest("bucketName");

// "/" is the delimiter of folders.
listObjectsRequest.set_delimiter("/");

// List all files and folders in the fun directory.
listObjectsRequest.set_prefix("fun/");

ListObjectsResponse listObjectsResponse;
int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
if (ret != 0) return;   
// Go through objects
std::cout << "\nObjectKeys:" << std::endl;
for(const ObjectSummary& objectSummary :listObjectsResponse.contents()) {
    std::cout << objectSummary.key << std::endl;
}
    
// Go through CommonPrefix
std::cout << "CommonPrefixs:" << std::endl;
for (const std::string& commonPrefix : listObjectsResponse.common_prefixes()) {
    std::cout << commonPrefix << std::endl;
}

ObjectKeys:
fun/
fun/test.jpg

CommonPrefixs:
fun/movie/

public void listObjectsStorageClass(){
    ListObjectsRequest listObjectsRequest("bucketName");
    ListObjectsResponse listObjectsResponse;
    int ret = client.list_objects(listObjectsRequest, &listObjectsResponse);
    std::vector<ObjectSummary> objectList = listObjectResponse.contents();
    for(int i = 0; i<objectList.size(); i++) {
        std::cout << objectList[i].storage_class() << std::endl;
    }
}

struct BceRequestContext {
    BceRequest *request;
    BceResponse *response;
    bool is_own;
};
int send_request(int n, BceRequestContext ctx[], int max_parallel = 0);

int deleteObject(Client& client,const std::string bucketName, const std::string objectKey) {

    // Delete an object
    return client.delete_object(bucketName, objectKey);           // Specify the bucket name of object to delete and the object name.
}

int deleteMultiObject(Client& client, const& std::string bucketName, const std::vector<std::string>& objects) { 
    //Delete objects in batch
    std::vector<BceRequestContext> ctx(objects.size());
    int i = 0;
    for (const std::string& objectKey : objects) {
        // Construct the context information.
        ctx[i].request = new DeleteObjectRequest(bucketName, objectKey);
        ctx[i].response = new DeleteObjectResponse;
        ctx[i].is_own = true;// Destruct the request and response automatically.
        ++i;
    }
    //Concurrent request
    int ret = client.send_request((int)ctx.size(), &ctx.front());
    if (ret != 0) return ret;
    //Handle the response
    for (size_t i = 0; i < ctx.size(); ++i) {
        DeleteObjectRequest* request = (DeleteObjectRequest*)ctx[i].request;
        DeleteObjectResponse* response = (DeleteObjectResponse*)ctx[i].response;
        if (response->is_fail()) {// Some requests fail to delete. Handle this situation.
            std::cout << "delete objectKey=" << request->object_name() << " failed"
                            << " reason: " << response->error().message();
            ret = RET_SERVICE_ERROR;
        }
    }
    return ret;
}

HeadObjectRequest request(bucketName, objectKey);
HeadObjectResponse response;
int ret = client.head_object(request, &response);
if (response.status_code() == 404) {
    std::cout << "ObjectKey not exist!" << std::endl;
}    

void setObjectMeta(Client& client, const std::string& bucketName, const std::string& objectKey, ObjectMetaData* newObjectMetadata) {
        
    CopyObjectRequest request(bucketName, objectKey, bucketName, objectKey);

    // Set a new ObjectMetadata.
    request.set_meta(newObjectMetadata);

    //Copy the object
    CopyObjectResponse copyObjectResponse;
    int ret = client.copy_object(request, &copyObjectResponse);
    if (ret != 0) {
        return;
    }
    //Print the result
    std::cout << "ETag: " << copyObjectResponse.etag() << " LastModified: " << copyObjectResponse.last_modified() << std::endl;
}

void copyObject(Client& client, std::string destBucketName, std::string destKey, const std::string& srcBucketName, const std::string& srcKey) {
    
    //Copy an object
    int ret = client.copy_object(srcBucketName, srcKey, destBucketName, destKey, "STANDARD");// The target object is standard storage.
}

//Initialize a client
Client client = ...;
    
// Create a CopyObjectRequest object.
CopyObjectRequest copyObjectRequest(destBucketName, destKey, srcBucketName, srcKey);
    
// Set a metadata.
ObjectMetaData* userMetadata = copyObjectRequest.mutable_meta();
userMetadata->set_user_meta("userMetaKey", "userMetaValue");
    
// Copy an object
CopyObjectResponse copyObjectResponse;
int ret = client.copy_object(copyObjectRequest, &copyObjectResponse);
    
std::cout << "ETag: " + copyObjectResponse.etag() <<
 " LastModified: " << copyObjectResponse.last_modified());

//Step 1:  init
InitMultiUploadRequest initMultiUploadRequest("targetBucketName","targetObjectName");
InitMultiUploadResponse initMultiUploadResponse;
client.init_multipart_upload(initMultiUploadRequest, &initMultiUploadResponse);
//Get the Object size
HeadObjectRequest request("targetBucketName", "targetObjectName");
HeadObjectResponse response;
client.head_object(request, &response);
if (response.is_fail()) {
    return RET_SERVICE_ERROR;
}
long left_size = response.meta().content_length();

//Step 2: Multipart copy
long skipBytes = 0;
int partNumber = 1;
std::vector<part_t> partETags;

while (left_size > 0) {
    long partSize = 1024 * 1024 * 1L;
    if (left_size < partSize) {
        partSize = left_size;
    }
    CopyPartRequest copyPartRequest;
    copyPartRequest.set_upload_id(initMultiUploadResponse.upload_id());
    copyPartRequest.set_bucket_name("targetBucketName");
    copyPartRequest.set_object_name("targetObjectName");
    copyPartRequest.set_source_bucket_name("sourceBucketName");
    copyPartRequest.set_source_object_name("sourceObjectName");
    copyPartRequest.set_range(skipBytes, skipBytes + partSize - 1);
    copyPartRequest.set_part_number(partNumber);

    CopyPartResponse copyPartResponse; 
    client.copy_part(copyPartRequest, &copyPartResponse);
    // Save the returned partNumber and ETag to the vector.
    part_t partInfo;
    partInfo.etag = copyPartResponse.etag(); 
    partInfo.part_number = partNumber;
    partETags.push_back(partI);
    left_size -= partSize;
    skipBytes += partSize;
    partNumber+=1;
}

// Step 3: Complete.
CompleteMultipartUploadRequest completeMultipartUploadRequest("targetBucketName", "targetObjectName", initMultiUploadResponse.upload_id());

// Add the part information, i.e., part merging order.
for (part_t partInfo : partEtags) {
    completeMultipartUploadRequest.add_part(partInfo.part_number, partInfo.etag);
}
    
// Complete MultiPartUpload.
CompleteMultipartUploadResponse completeMultipartUploadResponse;
int ret = client.complete_multipart_upload(completeMultipartUploadRequest, &completeMultipartUploadResponse);
    
// Print the ETag of objects.
std::cout << completeMultipartUploadResponse.etag() << std::endl;

client.parallel_copy(srcBucketName, sourceObjectName, destBucketName, destObjectName);

std::string filename = "test_archive";
FileInputStream file(filename);
PutObjectRequest request(bucket, "test_archive", &file);
request.mutable_meta()->set_storage_class("ARCHIVE");
PutObjectResponse result;
client.put_object(request, &result);

RestoreObjectRequest request(bucket, ""test_archive"");
RestoreObjectResponse response;
client.restore_object(request, &response);
print_common_response(response);