code stringlengths 1 1.05M | repo_name stringlengths 6 83 | path stringlengths 3 242 | language stringclasses 222 values | license stringclasses 20 values | size int64 1 1.05M |
|---|---|---|---|---|---|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/Owner.h>
namespace AlibabaCloud
{
namespace OSS
{
class ListBucketsResult;
class ALIBABACLOUD_OSS_EXPORT Bucket
{
public:
Bucket() = default;
~Bucket();
const std::string& Location() const { return location_; }
const std::string& Name() const { return name_; }
const std::string& CreationDate() const { return creationDate_; }
const std::string& IntranetEndpoint() const { return intranetEndpoint_; }
const std::string& ExtranetEndpoint() const { return extranetEndpoint_; }
AlibabaCloud::OSS::StorageClass StorageClass() const { return storageClass_; }
const AlibabaCloud::OSS::Owner& Owner() const { return owner_; }
private:
friend class ListBucketsResult;
std::string location_;
std::string name_;
std::string creationDate_;
std::string intranetEndpoint_;
std::string extranetEndpoint_;
AlibabaCloud::OSS::StorageClass storageClass_;
AlibabaCloud::OSS::Owner owner_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/Bucket.h | C++ | apache-2.0 | 1,804 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <string>
#include <list>
namespace AlibabaCloud
{
namespace OSS
{
using CORSAllowedList = std::list<std::string>;
class ALIBABACLOUD_OSS_EXPORT CORSRule
{
public:
static const int UNSET_AGE_SEC = -1;
public:
CORSRule() : maxAgeSeconds_(UNSET_AGE_SEC) {}
const CORSAllowedList& AllowedOrigins() const { return allowedOrigins_; }
const CORSAllowedList& AllowedMethods() const { return allowedMethods_; }
const CORSAllowedList& AllowedHeaders() const { return allowedHeaders_; }
const CORSAllowedList& ExposeHeaders() const { return exposeHeaders_; }
int MaxAgeSeconds() const { return maxAgeSeconds_; }
void addAllowedOrigin(const std::string& origin) { allowedOrigins_.push_back(origin); }
void addAllowedMethod(const std::string& method) { allowedMethods_.push_back(method); }
void addAllowedHeader(const std::string& header) { allowedHeaders_.push_back(header); }
void addExposeHeader(const std::string& header) { exposeHeaders_.push_back(header); }
void setMaxAgeSeconds(int value) { maxAgeSeconds_ = value; }
void clear()
{
allowedOrigins_.clear();
allowedMethods_.clear();
allowedHeaders_.clear();
exposeHeaders_.clear();
maxAgeSeconds_ = UNSET_AGE_SEC;
}
private:
CORSAllowedList allowedOrigins_;
CORSAllowedList allowedMethods_;
CORSAllowedList allowedHeaders_;
CORSAllowedList exposeHeaders_;
int maxAgeSeconds_;
};
using CORSRuleList = std::list<CORSRule>;
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CORSRule.h | C++ | apache-2.0 | 2,311 |
/*
* Copyright 2009-2018 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/model/Part.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
#include <sstream>
#include <iostream>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT CompleteMultipartUploadRequest: public OssObjectRequest
{
public:
CompleteMultipartUploadRequest(const std::string& bucket, const std::string& key);
CompleteMultipartUploadRequest(const std::string& bucket, const std::string& key,
const PartList& partList);
CompleteMultipartUploadRequest(const std::string& bucket, const std::string& key,
const PartList& partList,
const std::string& uploadId);
void setEncodingType(const std::string& encodingType);
void setPartList(const AlibabaCloud::OSS::PartList& partList);
void setUploadId(const std::string& uploadId);
void setAcl(CannedAccessControlList acl);
void setCallback(const std::string& callback, const std::string& callbackVar = "");
ObjectMetaData& MetaData();
protected:
virtual std::string payload() const;
virtual ParameterCollection specialParameters() const;
virtual HeaderCollection specialHeaders() const;
virtual int validate() const;
private:
AlibabaCloud::OSS::PartList partList_;
std::string uploadId_;
std::string encodingType_;
bool encodingTypeIsSet_;
ObjectMetaData metaData_;
};
}
} | YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CompleteMultipartUploadRequest.h | C++ | apache-2.0 | 2,181 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT CompleteMultipartUploadResult: public OssObjectResult
{
public:
CompleteMultipartUploadResult();
CompleteMultipartUploadResult(const std::string& data);
CompleteMultipartUploadResult(const std::shared_ptr<std::iostream>& data,
const HeaderCollection& headers);
CompleteMultipartUploadResult& operator=(const std::string& data);
const std::string& Location() const;
const std::string& Bucket() const;
const std::string& Key() const;
const std::string& ETag() const;
const std::string& EncodingType() const;
uint64_t CRC64() const;
const std::shared_ptr<std::iostream>& Content() const;
private:
std::string location_;
std::string bucket_;
std::string key_;
std::string eTag_;
std::string encodingType_;
uint64_t crc64_;
std::shared_ptr<std::iostream> content_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CompleteMultipartUploadResult.h | C++ | apache-2.0 | 1,825 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT CopyObjectRequest: public OssObjectRequest
{
public:
CopyObjectRequest(const std::string& bucket, const std::string& key);
CopyObjectRequest(const std::string& bucket, const std::string& key,
const ObjectMetaData& meta);
void setCopySource(const std::string& srcBucket,const std::string& srcObject);
void setSourceIfMatchETag(const std::string& value);
void setSourceIfNotMatchETag(const std::string& value);
void setSourceIfUnModifiedSince(const std::string& value);
void setSourceIfModifiedSince(const std::string& value);
void setMetadataDirective(const CopyActionList& action);
void setAcl(const CannedAccessControlList& acl);
void setTagging(const std::string& value);
void setTaggingDirective(const CopyActionList& action);
void setTrafficLimit(uint64_t value);
protected:
virtual HeaderCollection specialHeaders() const ;
virtual ParameterCollection specialParameters() const;
private:
std::string sourceBucket_;
std::string sourceKey_;
ObjectMetaData metaData_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CopyObjectRequest.h | C++ | apache-2.0 | 2,082 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/ServiceRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT CopyObjectResult : public OssObjectResult
{
public:
CopyObjectResult();
CopyObjectResult(const std::string& data);
CopyObjectResult(const std::shared_ptr<std::iostream>& data);
CopyObjectResult(const HeaderCollection& headers, const std::shared_ptr<std::iostream>& data);
CopyObjectResult& operator=(const std::string& data);
const std::string& ETag() const { return etag_; }
const std::string& LastModified() const { return lastModified_; }
const std::string& SourceVersionId() { return sourceVersionId_; }
void setEtag(const std::string& etag) { etag_ = etag; }
void setLastModified(const std::string& lastModified) { lastModified_ = lastModified; }
void setVersionId(const std::string& versionId) { versionId_ = versionId; }
void setRequestId(const std::string& requestId) { requestId_ = requestId; }
private:
std::string etag_;
std::string lastModified_;
std::string sourceVersionId_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CopyObjectResult.h | C++ | apache-2.0 | 1,943 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT CreateBucketRequest: public OssBucketRequest
{
public:
CreateBucketRequest(const std::string& bucket, StorageClass storageClass = StorageClass::Standard);
CreateBucketRequest(const std::string& bucket, StorageClass storageClass,
CannedAccessControlList acl);
void setDataRedundancyType(DataRedundancyType type) { dataRedundancyType_ = type; }
protected:
virtual std::string payload() const;
virtual HeaderCollection specialHeaders() const;
private:
StorageClass storageClass_;
CannedAccessControlList acl_;
DataRedundancyType dataRedundancyType_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CreateBucketRequest.h | C++ | apache-2.0 | 1,525 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/model/InputFormat.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT CreateSelectObjectMetaRequest : public OssObjectRequest
{
public:
CreateSelectObjectMetaRequest(const std::string& bucket, const std::string& key);
void setOverWriteIfExists(bool overWriteIfExist);
void setInputFormat(InputFormat& inputFormat);
protected:
virtual int validate() const;
virtual std::string payload() const;
virtual ParameterCollection specialParameters() const;
private:
InputFormat *inputFormat_;
bool overWriteIfExists_;
};
}
} | YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CreateSelectObjectMetaRequest.h | C++ | apache-2.0 | 1,340 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/OssResult.h>
#include <memory>
#include <iostream>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT CreateSelectObjectMetaResult : public OssResult
{
public:
CreateSelectObjectMetaResult();
CreateSelectObjectMetaResult(
const std::string& bucket,
const std::string& key,
const std::string& requestId,
const std::shared_ptr<std::iostream>& data);
CreateSelectObjectMetaResult& operator=(const std::shared_ptr<std::iostream>& data);
const std::string& Bucket() const { return bucket_; }
const std::string& Key() const { return key_; }
uint64_t Offset() const { return offset_; }
uint64_t TotalScanned() const { return totalScanned_; }
uint32_t Status() const { return status_; }
uint32_t SplitsCount() const { return splitsCount_; }
uint64_t RowsCount() const { return rowsCount_; }
uint32_t ColsCount() const { return colsCount_; }
const std::string& ErrorMessage() const { return errorMessage_; }
private:
std::string bucket_;
std::string key_;
uint64_t offset_;
uint64_t totalScanned_;
uint32_t status_;
uint32_t splitsCount_;
uint64_t rowsCount_;
uint32_t colsCount_;
std::string errorMessage_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CreateSelectObjectMetaResult.h | C++ | apache-2.0 | 2,032 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT CreateSymlinkRequest: public OssObjectRequest
{
public:
CreateSymlinkRequest(const std::string& bucket, const std::string& key);
CreateSymlinkRequest(const std::string& bucket, const std::string& key,
const ObjectMetaData& meta);
void SetSymlinkTarget(const std::string& value);
void setTagging(const std::string& value);
protected:
virtual HeaderCollection specialHeaders() const ;
virtual ParameterCollection specialParameters() const;
private:
ObjectMetaData metaData_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CreateSymlinkRequest.h | C++ | apache-2.0 | 1,491 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/ServiceRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT CreateSymlinkResult : public OssObjectResult
{
public:
CreateSymlinkResult();
CreateSymlinkResult(const std::string& etag);
CreateSymlinkResult(const HeaderCollection& headers);
const std::string& ETag() const { return etag_; }
private:
std::string etag_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/CreateSymlinkResult.h | C++ | apache-2.0 | 1,217 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketCorsRequest : public OssBucketRequest
{
public:
DeleteBucketCorsRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketCorsRequest.h | C++ | apache-2.0 | 1,013 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketEncryptionRequest : public OssBucketRequest
{
public:
DeleteBucketEncryptionRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketEncryptionRequest.h | C++ | apache-2.0 | 1,021 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketInventoryConfigurationRequest : public OssBucketRequest
{
public:
DeleteBucketInventoryConfigurationRequest(const std::string& bucket);
DeleteBucketInventoryConfigurationRequest(const std::string& bucket, const std::string& id);
void setId(const std::string& id) { id_ = id; }
protected:
virtual ParameterCollection specialParameters() const;
private:
std::string id_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketInventoryConfigurationRequest.h | C++ | apache-2.0 | 1,240 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/model/LifecycleRule.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketLifecycleRequest : public OssBucketRequest
{
public:
DeleteBucketLifecycleRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketLifecycleRequest.h | C++ | apache-2.0 | 1,074 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketLoggingRequest : public OssBucketRequest
{
public:
DeleteBucketLoggingRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketLoggingRequest.h | C++ | apache-2.0 | 1,020 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketPolicyRequest : public OssBucketRequest
{
public:
DeleteBucketPolicyRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketPolicyRequest.h | C++ | apache-2.0 | 1,018 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketQosInfoRequest : public OssBucketRequest
{
public:
DeleteBucketQosInfoRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketQosInfoRequest.h | C++ | apache-2.0 | 1,015 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketRequest : public OssBucketRequest
{
public:
DeleteBucketRequest(const std::string& bucket):
OssBucketRequest(bucket)
{
}
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketRequest.h | C++ | apache-2.0 | 984 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketTaggingRequest : public OssBucketRequest
{
public:
DeleteBucketTaggingRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketTaggingRequest.h | C++ | apache-2.0 | 1,015 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteBucketWebsiteRequest : public OssBucketRequest
{
public:
DeleteBucketWebsiteRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteBucketWebsiteRequest.h | C++ | apache-2.0 | 1,019 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteLiveChannelRequest : public LiveChannelRequest
{
public:
DeleteLiveChannelRequest(const std::string& bucket, const std::string& channelName);
protected:
virtual ParameterCollection specialParameters() const;
virtual int validate() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteLiveChannelRequest.h | C++ | apache-2.0 | 1,087 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteObjectRequest : public OssObjectRequest
{
public:
DeleteObjectRequest(const std::string& bucket, const std::string& key):
OssObjectRequest(bucket, key)
{
}
DeleteObjectRequest(const std::string& bucket, const std::string& key, const std::string& versionId) :
OssObjectRequest(bucket, key)
{
versionId_ = versionId;
}
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteObjectRequest.h | C++ | apache-2.0 | 1,223 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteObjectResult : public OssObjectResult
{
public:
DeleteObjectResult();
DeleteObjectResult(const HeaderCollection& header);
bool DeleteMarker() const;
private:
bool deleteMarker_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteObjectResult.h | C++ | apache-2.0 | 1,108 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteObjectTaggingRequest : public OssObjectRequest
{
public:
DeleteObjectTaggingRequest(const std::string& bucket, const std::string& key);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteObjectTaggingRequest.h | C++ | apache-2.0 | 1,076 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteObjectTaggingResult : public OssObjectResult
{
public:
DeleteObjectTaggingResult():OssObjectResult(){}
DeleteObjectTaggingResult(const HeaderCollection& headers) : OssObjectResult(headers) {}
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteObjectTaggingResult.h | C++ | apache-2.0 | 1,062 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <list>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT ObjectIdentifier
{
public:
ObjectIdentifier() {};
ObjectIdentifier(const std::string& key) : key_(key) {};
ObjectIdentifier(const std::string& key, const std::string& versionId) : key_(key), versionId_(versionId) {};
void setKey(const std::string& key) { key_ = key; };
void setVersionId(const std::string& versionId) { versionId_ = versionId; };
const std::string& Key() const { return key_; }
const std::string& VersionId() const { return versionId_; }
private:
std::string key_;
std::string versionId_;
};
using ObjectIdentifierList = std::vector<ObjectIdentifier>;
class ALIBABACLOUD_OSS_EXPORT DeleteObjectVersionsRequest : public OssBucketRequest
{
public:
DeleteObjectVersionsRequest(const std::string& bucket);
bool Quiet() const;
const std::string& EncodingType() const;
void setQuiet(bool quiet);
void setEncodingType(const std::string& value);
void addObject(const ObjectIdentifier& object);
void setObjects(const ObjectIdentifierList& objects);
const ObjectIdentifierList& Objects() const;
void clearObjects();
void setRequestPayer(RequestPayer value);
protected:
virtual std::string payload() const;
virtual ParameterCollection specialParameters() const;
virtual HeaderCollection specialHeaders() const;
private:
bool quiet_;
std::string encodingType_;
ObjectIdentifierList objects_;
RequestPayer requestPayer_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteObjectVersionsRequest.h | C++ | apache-2.0 | 2,419 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/OssResult.h>
#include <memory>
#include <iostream>
#include <list>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeletedObject
{
public:
DeletedObject():deleteMarker_(false) {}
const std::string& Key() const { return key_; }
const std::string& VersionId() const { return versionId_; }
const std::string& DeleteMarkerVersionId() const { return deleteMarkerVersionId_; }
bool DeleteMarker() const { return deleteMarker_; }
void setKey(const std::string& value) { key_ = value; }
void setVersionId(const std::string& value) { versionId_ = value; }
void setDeleteMarkerVersionId(const std::string& value) { deleteMarkerVersionId_ = value; }
void setDeleteMarker(bool value) { deleteMarker_ = value; }
private:
std::string key_;
std::string versionId_;
std::string deleteMarkerVersionId_;
bool deleteMarker_;
};
using DeletedObjectList = std::vector<DeletedObject>;
class ALIBABACLOUD_OSS_EXPORT DeleteObjectVersionsResult : public OssResult
{
public:
DeleteObjectVersionsResult();
DeleteObjectVersionsResult(const std::string& data);
DeleteObjectVersionsResult(const std::shared_ptr<std::iostream>& data);
DeleteObjectVersionsResult& operator=(const std::string& data);
bool Quiet() const;
const DeletedObjectList& DeletedObjects() const;
private:
bool quiet_;
DeletedObjectList deletedObjects_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteObjectVersionsResult.h | C++ | apache-2.0 | 2,272 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <list>
namespace AlibabaCloud
{
namespace OSS
{
using DeletedKeyList = std::list<std::string>;
class ALIBABACLOUD_OSS_EXPORT DeleteObjectsRequest : public OssBucketRequest
{
public:
DeleteObjectsRequest(const std::string& bucket);
bool Quiet() const;
const std::string& EncodingType() const;
const DeletedKeyList& KeyList() const;
void setQuiet(bool quiet);
void setEncodingType(const std::string& value);
void addKey(const std::string& key);
void setKeyList(const DeletedKeyList& keyList);
void clearKeyList();
void setRequestPayer(RequestPayer value);
protected:
virtual std::string payload() const;
virtual ParameterCollection specialParameters() const;
virtual HeaderCollection specialHeaders() const;
private:
bool quiet_;
std::string encodingType_;
DeletedKeyList keyList_;
RequestPayer requestPayer_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteObjectsRequest.h | C++ | apache-2.0 | 1,709 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/OssResult.h>
#include <memory>
#include <iostream>
#include <list>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DeleteObjectsResult : public OssResult
{
public:
DeleteObjectsResult();
DeleteObjectsResult(const std::string& data);
DeleteObjectsResult(const std::shared_ptr<std::iostream>& data);
DeleteObjectsResult& operator=(const std::string& data);
bool Quiet() const;
const std::list<std::string>& keyList() const;
private:
bool quiet_;
std::list<std::string> keyList_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DeleteObjectsResult.h | C++ | apache-2.0 | 1,261 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT DownloadObjectRequest : public OssResumableBaseRequest
{
public:
DownloadObjectRequest(const std::string& bucket, const std::string& key,
const std::string& filePath);
DownloadObjectRequest(const std::string& bucket, const std::string& key,
const std::string& filePath, const std::string& checkpointDir,
const uint64_t partSize, const uint32_t threadNum);
DownloadObjectRequest(const std::string& bucket, const std::string& key,
const std::string& filePath, const std::string& checkpointDir);
const std::string& FilePath() const { return filePath_; }
const std::string& TempFilePath() const { return tempFilePath_; }
DownloadObjectRequest(const std::string& bucket, const std::string& key,
const std::wstring& filePath);
DownloadObjectRequest(const std::string& bucket, const std::string& key,
const std::wstring& filePath, const std::wstring& checkpointDir,
const uint64_t partSize, const uint32_t threadNum);
DownloadObjectRequest(const std::string& bucket, const std::string& key,
const std::wstring& filePath, const std::wstring& checkpointDir);
const std::wstring& FilePathW() const { return filePathW_; }
const std::wstring& TempFilePathW() const { return tempFilePathW_; }
std::shared_ptr<std::iostream> Content() { return content_; }
bool RangeIsSet() const{ return rangeIsSet_; }
int64_t RangeStart() const { return range_[0]; }
int64_t RangeEnd() const { return range_[1]; }
const std::string& ModifiedSinceConstraint() const { return modifiedSince_; }
const std::string& UnmodifiedSinceConstraint() const { return unmodifiedSince_; }
const std::vector<std::string>& MatchingETagsConstraint() const { return matchingETags_; }
const std::vector<std::string>& NonmatchingETagsConstraint() const { return nonmatchingETags_;}
const std::map<std::string, std::string>& ResponseHeaderParameters() const { return responseHeaderParameters_; }
void setRange(int64_t start, int64_t end);
void setModifiedSinceConstraint(const std::string& gmt);
void setUnmodifiedSinceConstraint(const std::string& gmt);
void setMatchingETagConstraints(const std::vector<std::string>& match);
void setNonmatchingETagConstraints(const std::vector<std::string>& match);
void addResponseHeaders(RequestResponseHeader header, const std::string& value);
protected:
virtual int validate() const;
private:
bool rangeIsSet_;
int64_t range_[2];
std::string modifiedSince_;
std::string unmodifiedSince_;
std::vector<std::string> matchingETags_;
std::vector<std::string> nonmatchingETags_;
std::string filePath_;
std::string tempFilePath_;
std::shared_ptr<std::iostream> content_;
std::map<std::string, std::string> responseHeaderParameters_;
std::wstring filePathW_;
std::wstring tempFilePathW_;
};
}
} | YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/DownloadObjectRequest.h | C++ | apache-2.0 | 4,043 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
#include <alibabacloud/oss/http/HttpType.h>
namespace AlibabaCloud
{
namespace OSS
{
class OssClientImpl;
class ALIBABACLOUD_OSS_EXPORT GeneratePresignedUrlRequest
{
public:
GeneratePresignedUrlRequest(const std::string& bucket, const std::string& key);
GeneratePresignedUrlRequest(const std::string& bucket, const std::string& key,
Http::Method method);
void setBucket(const std::string& bucket);
void setKey(const std::string& key);
void setContentType(const std::string& value);
void setContentMd5(const std::string& value);
void setExpires(int64_t unixTime);
void setProcess(const std::string& process);
void setTrafficLimit(uint64_t value);
void setVersionId(const std::string& versionId);
void setRequestPayer(RequestPayer value);
void addResponseHeaders(RequestResponseHeader header, const std::string& value);
void addParameter(const std::string& key, const std::string& value);
MetaData& UserMetaData();
private:
friend class OssClientImpl;
std::string bucket_;
std::string key_;
Http::Method method_;
ObjectMetaData metaData_;
ParameterCollection parameters_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GeneratePresignedUrlRequest.h | C++ | apache-2.0 | 2,081 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <string>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GenerateRTMPSignedUrlRequest: public LiveChannelRequest
{
public:
GenerateRTMPSignedUrlRequest(const std::string& bucket,
const std::string& channelName, const std::string& playlist,
uint64_t expires);
void setExpires(uint64_t expires);
void setPlayList(const std::string &playList);
const std::string& PlayList() const;
uint64_t Expires() const;
virtual ParameterCollection Parameters() const;
private:
std::string playList_;
uint64_t expires_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GenerateRTMPSignedUrlRequest.h | C++ | apache-2.0 | 1,410 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketAclRequest: public OssBucketRequest
{
public:
GetBucketAclRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketAclRequest.h | C++ | apache-2.0 | 1,004 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/Owner.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketAclResult : public OssResult
{
public:
GetBucketAclResult();
GetBucketAclResult(const std::string& data);
GetBucketAclResult(const std::shared_ptr<std::iostream>& data);
GetBucketAclResult& operator=(const std::string& data);
const AlibabaCloud::OSS::Owner& Owner() { return owner_; }
CannedAccessControlList Acl()const { return acl_; }
private:
AlibabaCloud::OSS::Owner owner_;
CannedAccessControlList acl_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketAclResult.h | C++ | apache-2.0 | 1,380 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketCorsRequest: public OssBucketRequest
{
public:
GetBucketCorsRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketCorsRequest.h | C++ | apache-2.0 | 1,006 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/CORSRule.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketCorsResult : public OssResult
{
public:
GetBucketCorsResult();
GetBucketCorsResult(const std::string& data);
GetBucketCorsResult(const std::shared_ptr<std::iostream>& data);
GetBucketCorsResult& operator=(const std::string& data);
const CORSRuleList& CORSRules() const { return ruleList_; };
private:
CORSRuleList ruleList_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketCorsResult.h | C++ | apache-2.0 | 1,244 |
#pragma once
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketEncryptionRequest : public OssBucketRequest
{
public:
GetBucketEncryptionRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketEncryptionRequest.h | C++ | apache-2.0 | 1,028 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketEncryptionResult : public OssResult
{
public:
GetBucketEncryptionResult();
GetBucketEncryptionResult(const std::string& data);
GetBucketEncryptionResult(const std::shared_ptr<std::iostream>& data);
GetBucketEncryptionResult& operator=(const std::string& data);
AlibabaCloud::OSS::SSEAlgorithm SSEAlgorithm() const { return SSEAlgorithm_; }
const std::string& KMSMasterKeyID() const { return KMSMasterKeyID_; }
private:
AlibabaCloud::OSS::SSEAlgorithm SSEAlgorithm_;
std::string KMSMasterKeyID_;
};
}
} | YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketEncryptionResult.h | C++ | apache-2.0 | 1,418 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketInfoRequest: public OssBucketRequest
{
public:
GetBucketInfoRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketInfoRequest.h | C++ | apache-2.0 | 1,006 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/Owner.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketInfoResult : public OssResult
{
public:
GetBucketInfoResult();
GetBucketInfoResult(const std::string& data);
GetBucketInfoResult(const std::shared_ptr<std::iostream>& data);
GetBucketInfoResult& operator=(const std::string& data);
const std::string& Location() const { return location_; }
const std::string& Name() const { return name_; }
const std::string& CreationDate() const { return creationDate_; }
const std::string& IntranetEndpoint() const { return intranetEndpoint_; }
const std::string& ExtranetEndpoint() const { return extranetEndpoint_; }
AlibabaCloud::OSS::StorageClass StorageClass() const { return storageClass_; }
CannedAccessControlList Acl() const { return acl_; }
const AlibabaCloud::OSS::Owner& Owner() { return owner_; }
AlibabaCloud::OSS::DataRedundancyType DataRedundancyType() const { return dataRedundancyType_; }
const std::string& Comment() const { return comment_; }
AlibabaCloud::OSS::SSEAlgorithm SSEAlgorithm() { return sseAlgorithm_; }
const std::string& KMSMasterKeyID() { return kmsMasterKeyID_; }
AlibabaCloud::OSS::VersioningStatus VersioningStatus() { return versioningStatus_; }
private:
std::string location_;
std::string name_;
std::string creationDate_;
std::string intranetEndpoint_;
std::string extranetEndpoint_;
AlibabaCloud::OSS::StorageClass storageClass_;
CannedAccessControlList acl_;
AlibabaCloud::OSS::Owner owner_;
AlibabaCloud::OSS::DataRedundancyType dataRedundancyType_;
std::string comment_;
AlibabaCloud::OSS::SSEAlgorithm sseAlgorithm_;
std::string kmsMasterKeyID_;
AlibabaCloud::OSS::VersioningStatus versioningStatus_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketInfoResult.h | C++ | apache-2.0 | 2,789 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketInventoryConfigurationRequest : public OssBucketRequest
{
public:
GetBucketInventoryConfigurationRequest(const std::string& bucket);
GetBucketInventoryConfigurationRequest(const std::string& bucket, const std::string& id);
void setId(const std::string& id) { id_ = id; }
protected:
virtual ParameterCollection specialParameters() const;
private:
std::string id_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketInventoryConfigurationRequest.h | C++ | apache-2.0 | 1,231 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/InventoryConfiguration.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketInventoryConfigurationResult : public OssResult
{
public:
GetBucketInventoryConfigurationResult();
GetBucketInventoryConfigurationResult(const std::string& data);
GetBucketInventoryConfigurationResult(const std::shared_ptr<std::iostream>& data);
GetBucketInventoryConfigurationResult& operator=(const std::string& data);
AlibabaCloud::OSS::InventoryConfiguration InventoryConfiguration()const { return inventoryConfiguration_; }
private:
AlibabaCloud::OSS::InventoryConfiguration inventoryConfiguration_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketInventoryConfigurationResult.h | C++ | apache-2.0 | 1,436 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketLifecycleRequest: public OssBucketRequest
{
public:
GetBucketLifecycleRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketLifecycleRequest.h | C++ | apache-2.0 | 1,016 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/LifecycleRule.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketLifecycleResult : public OssResult
{
public:
GetBucketLifecycleResult();
GetBucketLifecycleResult(const std::string& data);
GetBucketLifecycleResult(const std::shared_ptr<std::iostream>& data);
GetBucketLifecycleResult& operator=(const std::string& data);
const LifecycleRuleList& LifecycleRules() { return lifecycleRuleList_; }
private:
LifecycleRuleList lifecycleRuleList_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketLifecycleResult.h | C++ | apache-2.0 | 1,302 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketLocationRequest: public OssBucketRequest
{
public:
GetBucketLocationRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketLocationRequest.h | C++ | apache-2.0 | 1,014 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketLocationResult : public OssResult
{
public:
GetBucketLocationResult();
GetBucketLocationResult(const std::string& data);
GetBucketLocationResult(const std::shared_ptr<std::iostream>& data);
GetBucketLocationResult& operator=(const std::string& data);
const std::string& Location() const { return location_; }
private:
std::string location_;
public:
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketLocationResult.h | C++ | apache-2.0 | 1,229 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketLoggingRequest: public OssBucketRequest
{
public:
GetBucketLoggingRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketLoggingRequest.h | C++ | apache-2.0 | 1,012 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketLoggingResult : public OssResult
{
public:
GetBucketLoggingResult();
GetBucketLoggingResult(const std::string& data);
GetBucketLoggingResult(const std::shared_ptr<std::iostream>& data);
GetBucketLoggingResult& operator=(const std::string& data);
const std::string& TargetBucket() const { return targetBucket_; }
const std::string& TargetPrefix() const { return targetPrefix_; }
private:
std::string targetBucket_;
std::string targetPrefix_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketLoggingResult.h | C++ | apache-2.0 | 1,332 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketRequestPaymentRequest: public OssBucketRequest
{
public:
GetBucketRequestPaymentRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketPaymentRequest.h | C++ | apache-2.0 | 1,026 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketPaymentResult : public OssResult
{
public:
GetBucketPaymentResult();
GetBucketPaymentResult(const std::string& data);
GetBucketPaymentResult(const std::shared_ptr<std::iostream>& data);
GetBucketPaymentResult& operator=(const std::string& data);
RequestPayer Payer()const { return payer_; }
private:
RequestPayer payer_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketPaymentResult.h | C++ | apache-2.0 | 1,233 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketPolicyRequest : public OssBucketRequest
{
public:
GetBucketPolicyRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketPolicyRequest.h | C++ | apache-2.0 | 1,011 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketPolicyResult : public OssResult
{
public:
GetBucketPolicyResult();
GetBucketPolicyResult(const std::string& data);
GetBucketPolicyResult(const std::shared_ptr<std::iostream>& data);
GetBucketPolicyResult& operator=(const std::string& data);
const std::string& Policy()const { return policy_; }
private:
std::string policy_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketPolicyResult.h | C++ | apache-2.0 | 1,201 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketQosInfoRequest : public OssBucketRequest
{
public:
GetBucketQosInfoRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketQosInfoRequest.h | C++ | apache-2.0 | 1,009 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/QosConfiguration.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketQosInfoResult : public OssResult
{
public:
GetBucketQosInfoResult();
GetBucketQosInfoResult(const std::string& data);
GetBucketQosInfoResult(const std::shared_ptr<std::iostream>& data);
GetBucketQosInfoResult& operator=(const std::string& data);
const QosConfiguration& QosInfo() const { return qosInfo_; }
private:
QosConfiguration qosInfo_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketQosInfoResult.h | C++ | apache-2.0 | 1,255 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketRefererRequest : public OssBucketRequest
{
public:
GetBucketRefererRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketRefererRequest.h | C++ | apache-2.0 | 1,013 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketRefererResult : public OssResult
{
public:
GetBucketRefererResult();
GetBucketRefererResult(const std::string& data);
GetBucketRefererResult(const std::shared_ptr<std::iostream>& data);
GetBucketRefererResult& operator=(const std::string& data);
const AlibabaCloud::OSS::RefererList& RefererList() const { return refererList_;}
bool AllowEmptyReferer() const { return allowEmptyReferer_; }
private:
AlibabaCloud::OSS::RefererList refererList_;
bool allowEmptyReferer_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketRefererResult.h | C++ | apache-2.0 | 1,397 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketStatRequest: public OssBucketRequest
{
public:
GetBucketStatRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketStatRequest.h | C++ | apache-2.0 | 1,006 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketStatResult : public OssResult
{
public:
GetBucketStatResult();
GetBucketStatResult(const std::string& data);
GetBucketStatResult(const std::shared_ptr<std::iostream>& data);
GetBucketStatResult& operator=(const std::string& data);
uint64_t Storage() const { return storage_; }
uint64_t ObjectCount() const { return objectCount_; }
uint64_t MultipartUploadCount() const { return multipartUploadCount_; }
private:
uint64_t storage_;
uint64_t objectCount_;
uint64_t multipartUploadCount_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketStatResult.h | C++ | apache-2.0 | 1,394 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketStorageCapacityRequest : public OssBucketRequest
{
public:
GetBucketStorageCapacityRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketStorageCapacityRequest.h | C++ | apache-2.0 | 1,029 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketStorageCapacityResult : public OssResult
{
public:
GetBucketStorageCapacityResult();
GetBucketStorageCapacityResult(const std::string& data);
GetBucketStorageCapacityResult(const std::shared_ptr<std::iostream>& data);
GetBucketStorageCapacityResult& operator=(const std::string& data);
int64_t StorageCapacity() const { return storageCapacity_; }
private:
int64_t storageCapacity_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketStorageCapacityResult.h | C++ | apache-2.0 | 1,295 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketTaggingRequest : public OssBucketRequest
{
public:
GetBucketTaggingRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketTaggingRequest.h | C++ | apache-2.0 | 1,009 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/Tagging.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketTaggingResult : public OssResult
{
public:
GetBucketTaggingResult();
GetBucketTaggingResult(const std::string& data);
GetBucketTaggingResult(const std::shared_ptr<std::iostream>& data);
GetBucketTaggingResult& operator=(const std::string& data);
const AlibabaCloud::OSS::Tagging& Tagging() const { return tagging_; };
private:
AlibabaCloud::OSS::Tagging tagging_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketTaggingResult.h | C++ | apache-2.0 | 1,278 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketVersioningRequest: public OssBucketRequest
{
public:
GetBucketVersioningRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketVersioningRequest.h | C++ | apache-2.0 | 1,051 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketVersioningResult : public OssResult
{
public:
GetBucketVersioningResult();
GetBucketVersioningResult(const std::string& data);
GetBucketVersioningResult(const std::shared_ptr<std::iostream>& data);
GetBucketVersioningResult& operator=(const std::string& data);
VersioningStatus Status() const { return status_; }
private:
VersioningStatus status_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketVersioningResult.h | C++ | apache-2.0 | 1,299 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketWebsiteRequest : public OssBucketRequest
{
public:
GetBucketWebsiteRequest(const std::string& bucket);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketWebsiteRequest.h | C++ | apache-2.0 | 1,013 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetBucketWebsiteResult: public OssResult
{
public:
GetBucketWebsiteResult();
GetBucketWebsiteResult(const std::string& data);
GetBucketWebsiteResult(const std::shared_ptr<std::iostream>& data);
GetBucketWebsiteResult& operator=(const std::string& data);
const std::string& IndexDocument() const { return indexDocument_; }
const std::string& ErrorDocument() const { return errorDocument_; }
private:
std::string indexDocument_;
std::string errorDocument_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetBucketWebsiteResult.h | C++ | apache-2.0 | 1,338 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
#include <alibabacloud/oss/http/HttpType.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetLiveChannelHistoryRequest : public LiveChannelRequest
{
public:
GetLiveChannelHistoryRequest(const std::string& bucket, const std::string& channelName);
protected:
virtual ParameterCollection specialParameters() const;
virtual int validate() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetLiveChannelHistoryRequest.h | C++ | apache-2.0 | 1,227 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <vector>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/Owner.h>
#include <alibabacloud/oss/ServiceRequest.h>
using std::vector;
namespace AlibabaCloud
{
namespace OSS
{
struct LiveRecord
{
std::string startTime;
std::string endTime;
std::string remoteAddr;
};
using LiveRecordVec = vector<LiveRecord>;
class ALIBABACLOUD_OSS_EXPORT GetLiveChannelHistoryResult : public OssResult
{
public:
GetLiveChannelHistoryResult();
GetLiveChannelHistoryResult(const std::string& data);
GetLiveChannelHistoryResult(const std::shared_ptr<std::iostream>& data);
GetLiveChannelHistoryResult& operator=(const std::string& data);
const LiveRecordVec& LiveRecordList() const;
private:
LiveRecordVec recordList_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetLiveChannelHistoryResult.h | C++ | apache-2.0 | 1,547 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
#include <alibabacloud/oss/http/HttpType.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetLiveChannelInfoRequest : public LiveChannelRequest
{
public:
GetLiveChannelInfoRequest(const std::string& bucket, const std::string& channelName);
protected:
virtual ParameterCollection specialParameters() const;
virtual int validate() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetLiveChannelInfoRequest.h | C++ | apache-2.0 | 1,221 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/Owner.h>
#include <alibabacloud/oss/ServiceRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetLiveChannelInfoResult : public OssResult
{
public:
GetLiveChannelInfoResult();
GetLiveChannelInfoResult(const std::string& data);
GetLiveChannelInfoResult(const std::shared_ptr<std::iostream>& data);
GetLiveChannelInfoResult& operator=(const std::string& data);
const std::string& Description() const;
LiveChannelStatus Status() const;
const std::string& Type() const;
uint64_t FragDuration() const;
uint64_t FragCount() const;
const std::string& PlaylistName() const;
private:
std::string channelType_;
LiveChannelStatus status_;
std::string description_;
std::string playListName_;
uint64_t fragDuration_;
uint64_t fragCount_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetLiveChannelInfoResult.h | C++ | apache-2.0 | 1,686 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
#include <alibabacloud/oss/http/HttpType.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetLiveChannelStatRequest : public LiveChannelRequest
{
public:
GetLiveChannelStatRequest(const std::string& bucket, const std::string& channelName);
protected:
virtual ParameterCollection specialParameters() const;
virtual int validate() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetLiveChannelStatRequest.h | C++ | apache-2.0 | 1,221 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/Owner.h>
#include <alibabacloud/oss/ServiceRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetLiveChannelStatResult : public OssResult
{
public:
GetLiveChannelStatResult();
GetLiveChannelStatResult(const std::string& data);
GetLiveChannelStatResult(const std::shared_ptr<std::iostream>& data);
GetLiveChannelStatResult& operator=(const std::string& data);
LiveChannelStatus Status() const;
const std::string& ConnectedTime() const;
const std::string& RemoteAddr() const;
uint32_t Width() const;
uint32_t Height() const;
uint64_t FrameRate() const;
uint64_t VideoBandWidth() const;
const std::string& VideoCodec() const;
uint64_t SampleRate() const;
uint64_t AudioBandWidth() const;
const std::string& AudioCodec() const;
private:
std::string connectedTime_;
LiveChannelStatus status_;
std::string remoteAddr_;
uint32_t width_;
uint32_t height_;
uint64_t frameRate_;
uint64_t videoBandWidth_;
std::string videoCodec_;
uint64_t sampleRate_;
uint64_t audioBandWidth_;
std::string audioCodec_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetLiveChannelStatResult.h | C++ | apache-2.0 | 2,032 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetObjectAclRequest: public OssObjectRequest
{
public:
GetObjectAclRequest(const std::string& bucket, const std::string& key);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetObjectAclRequest.h | C++ | apache-2.0 | 1,064 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/Owner.h>
#include <alibabacloud/oss/ServiceRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetObjectAclResult : public OssObjectResult
{
public:
GetObjectAclResult();
GetObjectAclResult(const std::string& data);
GetObjectAclResult(const std::shared_ptr<std::iostream>& data);
GetObjectAclResult(const HeaderCollection& headers, const std::shared_ptr<std::iostream>& data);
GetObjectAclResult& operator=(const std::string& data);
const AlibabaCloud::OSS::Owner& Owner() { return owner_; }
CannedAccessControlList Acl()const { return acl_; }
private:
AlibabaCloud::OSS::Owner owner_;
CannedAccessControlList acl_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetObjectAclResult.h | C++ | apache-2.0 | 1,562 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
#include <alibabacloud/oss/http/HttpType.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetObjectByUrlRequest: public ServiceRequest
{
public:
GetObjectByUrlRequest(const std::string& url);
GetObjectByUrlRequest(const std::string& url, const ObjectMetaData& metaData);
virtual HeaderCollection Headers() const;
virtual ParameterCollection Parameters() const;
virtual std::shared_ptr<std::iostream> Body() const;
private:
ObjectMetaData metaData_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetObjectByUrlRequest.h | C++ | apache-2.0 | 1,357 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetObjectMetaRequest : public OssObjectRequest
{
public:
GetObjectMetaRequest(const std::string& bucket, const std::string& key):
OssObjectRequest(bucket, key)
{
}
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetObjectMetaRequest.h | C++ | apache-2.0 | 1,093 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <vector>
#include <map>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetObjectRequest: public OssObjectRequest
{
public:
GetObjectRequest(const std::string& bucket, const std::string& key);
GetObjectRequest(const std::string& bucket, const std::string& key,
const std::string& process);
GetObjectRequest(const std::string &bucket, const std::string &key,
const std::string &modifiedSince, const std::string &unmodifiedSince,
const std::vector<std::string> &matchingETags, const std::vector<std::string> &nonmatchingETags,
const std::map<std::string, std::string> &responseHeaderParameters_);
void setRange(int64_t start, int64_t end);
void setRange(int64_t start, int64_t end, bool standard);
void setModifiedSinceConstraint(const std::string& gmt);
void setUnmodifiedSinceConstraint(const std::string& gmt);
void setMatchingETagConstraints(const std::vector<std::string>& match);
void addMatchingETagConstraint(const std::string& match);
void setNonmatchingETagConstraints(const std::vector<std::string>& match);
void addNonmatchingETagConstraint(const std::string& match);
void setProcess(const std::string& process);
void addResponseHeaders(RequestResponseHeader header, const std::string& value);
void setTrafficLimit(uint64_t value);
void setUserAgent(const std::string& ua);
std::pair<int64_t, int64_t> Range() const;
protected:
virtual HeaderCollection specialHeaders() const ;
virtual ParameterCollection specialParameters() const;
virtual int validate() const;
private:
int64_t range_[2];
bool rangeIsSet_;
std::string modifiedSince_;
std::string unmodifiedSince_;
std::vector<std::string> matchingETags_;
std::vector<std::string> nonmatchingETags_;
std::string process_;
std::map<std::string, std::string> responseHeaderParameters_;
uint64_t trafficLimit_;
bool rangeIsStandardMode_;
std::string userAgent_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetObjectRequest.h | C++ | apache-2.0 | 2,934 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
#include <alibabacloud/oss/ServiceRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetObjectResult :public OssObjectResult
{
public:
GetObjectResult();
GetObjectResult(const std::string& bucket, const std::string& key,
const std::shared_ptr<std::iostream>& content,
const HeaderCollection& headers);
GetObjectResult(const std::string& bucket, const std::string& key,
const ObjectMetaData& metaData);
const std::string& Bucket() const { return bucket_; }
const std::string& Key() const { return key_; }
const ObjectMetaData& Metadata() const { return metaData_; }
const std::shared_ptr<std::iostream>& Content() const { return content_; }
void setContent(const std::shared_ptr<std::iostream>& content) { content_ = content; }
void setMetaData(const ObjectMetaData& meta) { metaData_ = meta; }
private:
std::string bucket_;
std::string key_;
ObjectMetaData metaData_;
std::shared_ptr<std::iostream> content_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetObjectResult.h | C++ | apache-2.0 | 1,861 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetObjectTaggingRequest : public OssObjectRequest
{
public:
GetObjectTaggingRequest(const std::string& bucket, const std::string& key);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetObjectTaggingRequest.h | C++ | apache-2.0 | 1,070 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/Tagging.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetObjectTaggingResult : public OssObjectResult
{
public:
GetObjectTaggingResult();
GetObjectTaggingResult(const std::string& data);
GetObjectTaggingResult(const std::shared_ptr<std::iostream>& data);
GetObjectTaggingResult(const HeaderCollection& headers, const std::shared_ptr<std::iostream>& data);
GetObjectTaggingResult& operator=(const std::string& data);
const AlibabaCloud::OSS::Tagging& Tagging() const { return tagging_; };
private:
AlibabaCloud::OSS::Tagging tagging_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetObjectTaggingResult.h | C++ | apache-2.0 | 1,436 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <string>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetSymlinkRequest: public OssObjectRequest
{
public:
GetSymlinkRequest(const std::string& bucket, const std::string& key);
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetSymlinkRequest.h | C++ | apache-2.0 | 1,076 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/ServiceRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetSymlinkResult : public OssObjectResult
{
public:
public:
GetSymlinkResult();
GetSymlinkResult(const std::string& symlink,const std::string& etag);
GetSymlinkResult(const HeaderCollection& headers);
const std::string& SymlinkTarget() const { return symlink_; }
const std::string& ETag() const { return etag_; }
private:
std::string symlink_;
std::string etag_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetSymlinkResult.h | C++ | apache-2.0 | 1,351 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetUserQosInfoRequest : public OssRequest
{
public:
GetUserQosInfoRequest();
protected:
virtual ParameterCollection specialParameters() const;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetUserQosInfoRequest.h | C++ | apache-2.0 | 974 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/QosConfiguration.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetUserQosInfoResult : public OssResult
{
public:
GetUserQosInfoResult();
GetUserQosInfoResult(const std::string& data);
GetUserQosInfoResult(const std::shared_ptr<std::iostream>& data);
GetUserQosInfoResult& operator=(const std::string& data);
const QosConfiguration& QosInfo() const { return qosInfo_; }
const std::string& Region() const { return region_; }
private:
std::string region_;
QosConfiguration qosInfo_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetUserQosInfoResult.h | C++ | apache-2.0 | 1,348 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
#include <alibabacloud/oss/http/HttpType.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetVodPlaylistRequest : public LiveChannelRequest
{
public:
GetVodPlaylistRequest(const std::string& bucket,
const std::string& channelName);
GetVodPlaylistRequest(const std::string& bucket,
const std::string& channelName, uint64_t startTime,
uint64_t endTime);
void setStartTime(uint64_t startTime);
void setEndTime(uint64_t endTime);
protected:
virtual ParameterCollection specialParameters() const;
virtual int validate() const;
private:
uint64_t startTime_;
uint64_t endTime_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetVodPlaylistRequest.h | C++ | apache-2.0 | 1,540 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <vector>
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT GetVodPlaylistResult: public OssResult
{
public:
GetVodPlaylistResult();
GetVodPlaylistResult(const std::string& data);
GetVodPlaylistResult(const std::shared_ptr<std::iostream>& data);
GetVodPlaylistResult& operator=(const std::string& data);
const std::string& PlaylistContent() const;
private:
std::string playListContent_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/GetVodPlaylistResult.h | C++ | apache-2.0 | 1,215 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT HeadObjectRequest : public OssObjectRequest
{
public:
HeadObjectRequest(const std::string& bucket, const std::string& key):
OssObjectRequest(bucket, key)
{
}
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/HeadObjectRequest.h | C++ | apache-2.0 | 1,009 |
/*
* Copyright 2009-2018 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/model/ObjectMetaData.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT InitiateMultipartUploadRequest: public OssObjectRequest
{
public:
InitiateMultipartUploadRequest(const std::string& bucket, const std::string& key);
InitiateMultipartUploadRequest(const std::string& bucket, const std::string& key,
const ObjectMetaData& metaData);
void setCacheControl(const std::string& value);
void setContentDisposition(const std::string& value);
void setContentEncoding(const std::string& value);
void setExpires(const std::string& value);
ObjectMetaData& MetaData();
void setEncodingType(const std::string& encodingType);
void setTagging(const std::string& value);
void setSequential(bool value);
protected:
virtual HeaderCollection specialHeaders() const;
virtual ParameterCollection specialParameters() const;
private:
ObjectMetaData metaData_;
std::string encodingType_;
bool encodingTypeIsSet_;
bool sequential_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/InitiateMultipartUploadRequest.h | C++ | apache-2.0 | 1,904 |
/*
* Copyright 2009-2018 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <memory>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT InitiateMultipartUploadResult :public OssResult
{
public:
InitiateMultipartUploadResult();
InitiateMultipartUploadResult(const std::string& data);
InitiateMultipartUploadResult(const std::shared_ptr<std::iostream>& data);
InitiateMultipartUploadResult& operator=(const std::string& data);
const std::string& Bucket() const { return bucket_; }
const std::string& Key() const { return key_; }
const std::string& UploadId() const { return uploadId_; }
const std::string& EncodingType() const { return encodingType_; }
private:
std::string bucket_;
std::string key_;
std::string uploadId_;
std::string encodingType_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/InitiateMultipartUploadResult.h | C++ | apache-2.0 | 1,563 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/Types.h>
namespace AlibabaCloud
{
namespace OSS
{
enum CompressionType
{
NONE = 0,
GZIP
};
enum CSVHeader
{
None = 0, // there is no csv header
Ignore, // we should ignore csv header and should not use csv header in select sql
Use // we can use csv header in select sql
};
enum JsonType
{
DOCUMENT = 0,
LINES
};
class SelectObjectRequest;
class CreateSelectObjectMetaRequest;
class ALIBABACLOUD_OSS_EXPORT InputFormat
{
public:
void setCompressionType(CompressionType compressionType);
void setLineRange(int64_t start, int64_t end);
void setSplitRange(int64_t start, int64_t end);
const std::string CompressionTypeInfo() const;
protected:
InputFormat();
friend SelectObjectRequest;
friend CreateSelectObjectMetaRequest;
virtual int validate() const;
virtual std::string toXML(int flag) const = 0;
virtual std::string Type() const = 0;
std::string RangeToString() const;
private:
CompressionType compressionType_;
bool lineRangeIsSet_;
int64_t lineRange_[2];
bool splitRangeIsSet_;
int64_t splitRange_[2];
};
class ALIBABACLOUD_OSS_EXPORT CSVInputFormat : public InputFormat
{
public:
CSVInputFormat();
CSVInputFormat(CSVHeader headerInfo,
const std::string& recordDelimiter,
const std::string& fieldDelimiter,
const std::string& quoteChar,
const std::string& commentChar);
void setHeaderInfo(CSVHeader headerInfo);
void setRecordDelimiter(const std::string& recordDelimiter);
void setFieldDelimiter(const std::string& fieldDelimiter);
void setQuoteChar(const std::string& quoteChar);
void setCommentChar(const std::string& commentChar);
CSVHeader HeaderInfo() const;
const std::string& RecordDelimiter() const;
const std::string& FieldDelimiter() const;
const std::string& QuoteChar() const;
const std::string& CommentChar() const;
protected:
std::string Type() const;
std::string toXML(int flag) const;
private:
CSVHeader headerInfo_;
std::string recordDelimiter_;
std::string fieldDelimiter_;
std::string quoteChar_;
std::string commentChar_;
};
class ALIBABACLOUD_OSS_EXPORT JSONInputFormat : public InputFormat
{
public:
JSONInputFormat();
JSONInputFormat(JsonType jsonType);
void setJsonType(JsonType jsonType);
void setParseJsonNumberAsString(bool parseJsonNumberAsString);
JsonType JsonInfo() const;
bool ParseJsonNumberAsString() const;
protected:
std::string Type() const;
std::string toXML(int flag) const;
private:
JsonType jsonType_;
bool parseJsonNumberAsString_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/InputFormat.h | C++ | apache-2.0 | 3,704 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/Types.h>
#include <string>
#include <vector>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT InventoryFilter
{
public:
InventoryFilter();
InventoryFilter(const std::string& prefix);
const std::string& Prefix() const { return prefix_; }
void setPrefix(const std::string& prefix) { prefix_ = prefix; }
private:
std::string prefix_;
};
class ALIBABACLOUD_OSS_EXPORT InventorySSEOSS
{
public:
InventorySSEOSS();
};
class ALIBABACLOUD_OSS_EXPORT InventorySSEKMS
{
public:
InventorySSEKMS();
InventorySSEKMS(const std::string& key);
const std::string& KeyId() const { return keyId_; }
void setKeyId(const std::string& key) { keyId_ = key; }
private:
std::string keyId_;
};
class ALIBABACLOUD_OSS_EXPORT InventoryEncryption
{
public:
InventoryEncryption();
InventoryEncryption(const InventorySSEOSS& value);
InventoryEncryption(const InventorySSEKMS& value);
const InventorySSEOSS& SSEOSS() const { return inventorySSEOSS_; }
void setSSEOSS(const InventorySSEOSS& value) { inventorySSEOSS_ = value; inventorySSEOSIsSet_ = true; }
bool hasSSEOSS() const { return inventorySSEOSIsSet_; }
const InventorySSEKMS& SSEKMS() const { return inventorySSEKMS_; }
void setSSEKMS(const InventorySSEKMS& value) { inventorySSEKMS_ = value; inventorySSEKMSIsSet_ = true; }
bool hasSSEKMS() const { return inventorySSEKMSIsSet_; }
private:
InventorySSEOSS inventorySSEOSS_;
bool inventorySSEOSIsSet_;
InventorySSEKMS inventorySSEKMS_;
bool inventorySSEKMSIsSet_;
};
class ALIBABACLOUD_OSS_EXPORT InventoryOSSBucketDestination
{
public:
InventoryOSSBucketDestination();
InventoryFormat Format() const { return format_; }
const std::string& AccountId() const { return accountId_; }
const std::string& RoleArn() const { return roleArn_; }
const std::string& Bucket() const { return bucket_; }
const std::string& Prefix() const { return prefix_; }
const InventoryEncryption& Encryption() const { return encryption_; }
void setFormat(InventoryFormat format) { format_ = format; }
void setAccountId(const std::string& accountId) { accountId_ = accountId; }
void setRoleArn(const std::string& roleArn) { roleArn_ = roleArn; }
void setBucket(const std::string& bucket) { bucket_ = bucket; }
void setPrefix(const std::string& prefix) { prefix_ = prefix; }
void setEncryption(const InventoryEncryption& encryption) { encryption_ = encryption; }
private:
InventoryFormat format_;
std::string accountId_;
std::string roleArn_;
std::string bucket_;
std::string prefix_;
InventoryEncryption encryption_;
};
class InventoryDestination
{
public:
InventoryDestination() {}
InventoryDestination(const InventoryOSSBucketDestination& destination):InventoryOSSBucketDestination_(destination){}
const InventoryOSSBucketDestination& OSSBucketDestination() const { return InventoryOSSBucketDestination_; }
void setOSSBucketDestination(const InventoryOSSBucketDestination& destination) { InventoryOSSBucketDestination_ = destination; }
private:
InventoryOSSBucketDestination InventoryOSSBucketDestination_;
};
using InventoryOptionalFields = std::vector<InventoryOptionalField>;
class ALIBABACLOUD_OSS_EXPORT InventoryConfiguration
{
public:
InventoryConfiguration();
const std::string& Id() const { return id_; }
bool IsEnabled() const { return isEnabled_; }
const InventoryFilter& Filter() const { return filter_; }
const InventoryDestination& Destination() const { return destination_; }
const InventoryFrequency& Schedule() const { return schedule_; }
const InventoryIncludedObjectVersions& IncludedObjectVersions() const { return includedObjectVersions_; }
const InventoryOptionalFields& OptionalFields() const { return optionalFields_; }
void setId(const std::string& id) { id_ = id; }
void setIsEnabled(bool isEnabled) { isEnabled_ = isEnabled; }
void setFilter(const InventoryFilter& prefix) { filter_ = prefix; }
void setDestination(const InventoryDestination& destination) { destination_ = destination; }
void setSchedule(const InventoryFrequency& schedule) { schedule_ = schedule; }
void setIncludedObjectVersions(const InventoryIncludedObjectVersions& includedObjectVersions) { includedObjectVersions_ = includedObjectVersions; }
void setOptionalFields(const InventoryOptionalFields& opt) { optionalFields_ = opt; }
private:
std::string id_;
bool isEnabled_;
InventoryFilter filter_;
InventoryDestination destination_;
InventoryFrequency schedule_;
InventoryIncludedObjectVersions includedObjectVersions_;
InventoryOptionalFields optionalFields_;
};
using InventoryConfigurationList = std::vector<InventoryConfiguration>;
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/InventoryConfiguration.h | C++ | apache-2.0 | 5,950 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <string>
#include <vector>
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/Types.h>
#include <alibabacloud/oss/model/Tagging.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT LifeCycleExpiration
{
public:
LifeCycleExpiration();
LifeCycleExpiration(uint32_t days);
LifeCycleExpiration(const std::string& createdBeforeDate);
void setDays(uint32_t days);
void setCreatedBeforeDate(const std::string& date);
uint32_t Days() const { return days_; }
const std::string& CreatedBeforeDate() const { return createdBeforeDate_; }
private:
uint32_t days_;
std::string createdBeforeDate_;
};
class ALIBABACLOUD_OSS_EXPORT LifeCycleTransition
{
public:
LifeCycleTransition() = default;
LifeCycleTransition(const LifeCycleExpiration& expiration, AlibabaCloud::OSS::StorageClass storageClass);
void setExpiration(const LifeCycleExpiration& expiration);
void setStorageClass(AlibabaCloud::OSS::StorageClass storageClass);
const LifeCycleExpiration& Expiration() const { return expiration_; }
LifeCycleExpiration& Expiration() { return expiration_; }
AlibabaCloud::OSS::StorageClass StorageClass() const { return storageClass_; }
private:
LifeCycleExpiration expiration_;
AlibabaCloud::OSS::StorageClass storageClass_;
};
using LifeCycleTransitionList = std::vector<LifeCycleTransition>;
class ALIBABACLOUD_OSS_EXPORT LifecycleRule
{
public:
LifecycleRule();
const std::string& ID() const { return id_; }
const std::string& Prefix() const { return prefix_; }
RuleStatus Status() const { return status_;}
const LifeCycleExpiration& Expiration() const { return expiration_; }
const LifeCycleTransitionList& TransitionList() const { return transitionList_; }
const LifeCycleExpiration& AbortMultipartUpload() const { return abortMultipartUpload_; }
LifeCycleExpiration& Expiration() { return expiration_; }
LifeCycleTransitionList& TransitionList() { return transitionList_; }
LifeCycleExpiration& AbortMultipartUpload() { return abortMultipartUpload_; }
const TagSet& Tags() const { return tagSet_; }
TagSet& Tags() { return tagSet_; }
void setID(const std::string& id) { id_ = id; }
void setPrefix(const std::string& prefix) { prefix_ = prefix; }
void setStatus(RuleStatus status) { status_ = status; }
void setExpiration(const LifeCycleExpiration& expiration) { expiration_ = expiration; }
void addTransition(const LifeCycleTransition&transition) { transitionList_.push_back(transition); }
void setTransitionList(const LifeCycleTransitionList& transitionList) { transitionList_ = transitionList; }
void setAbortMultipartUpload(const LifeCycleExpiration& expiration) { abortMultipartUpload_ = expiration; }
void addTag(const Tag& tag) { tagSet_.push_back(tag); }
void setTags(const TagSet& tags) { tagSet_ = tags; }
bool hasExpiration() const;
bool hasTransitionList() const;
bool hasAbortMultipartUpload() const;
bool operator==(const LifecycleRule& right) const;
bool ExpiredObjectDeleteMarker() const { return expiredObjectDeleteMarker_; };
const LifeCycleExpiration& NoncurrentVersionExpiration() const { return noncurrentVersionExpiration_; }
const LifeCycleTransitionList& NoncurrentVersionTransitionList() const { return noncurrentVersionTransitionList_; }
LifeCycleExpiration& NoncurrentVersionExpiration() { return noncurrentVersionExpiration_; }
LifeCycleTransitionList& NoncurrentVersionTransitionList() { return noncurrentVersionTransitionList_; }
void setExpiredObjectDeleteMarker(bool value) { expiredObjectDeleteMarker_ = value; };
void setNoncurrentVersionExpiration(const LifeCycleExpiration& expiration) { noncurrentVersionExpiration_ = expiration; }
void addNoncurrentVersionTransition(const LifeCycleTransition&transition) { noncurrentVersionTransitionList_.push_back(transition); }
void setNoncurrentVersionTransitionList(const LifeCycleTransitionList& transitionList) { noncurrentVersionTransitionList_ = transitionList; }
bool hasNoncurrentVersionExpiration() const;
bool hasNoncurrentVersionTransitionList() const;
private:
std::string id_;
std::string prefix_;
RuleStatus status_;
LifeCycleExpiration expiration_;
LifeCycleTransitionList transitionList_;
LifeCycleExpiration abortMultipartUpload_;
TagSet tagSet_;
bool expiredObjectDeleteMarker_;
LifeCycleExpiration noncurrentVersionExpiration_;
LifeCycleTransitionList noncurrentVersionTransitionList_;
};
using LifecycleRuleList = std::vector<LifecycleRule>;
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/LifecycleRule.h | C++ | apache-2.0 | 5,722 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT ListBucketInventoryConfigurationsRequest : public OssBucketRequest
{
public:
ListBucketInventoryConfigurationsRequest(const std::string& bucket);
void setContinuationToken(const std::string& token) { continuationToken_ = token; }
protected:
virtual ParameterCollection specialParameters() const;
private:
std::string continuationToken_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/ListBucketInventoryConfigurationsRequest.h | C++ | apache-2.0 | 1,189 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
#include <alibabacloud/oss/model/InventoryConfiguration.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT ListBucketInventoryConfigurationsResult : public OssResult
{
public:
ListBucketInventoryConfigurationsResult();
ListBucketInventoryConfigurationsResult(const std::string& data);
ListBucketInventoryConfigurationsResult(const std::shared_ptr<std::iostream>& data);
ListBucketInventoryConfigurationsResult& operator=(const std::string& data);
const AlibabaCloud::OSS::InventoryConfigurationList& InventoryConfigurationList()const { return inventoryConfigurationList_; }
bool IsTruncated() const { return isTruncated_; }
const std::string& NextContinuationToken() const { return nextContinuationToken_; }
private:
AlibabaCloud::OSS::InventoryConfigurationList inventoryConfigurationList_;
bool isTruncated_;
std::string nextContinuationToken_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/ListBucketInventoryConfigurationsResult.h | C++ | apache-2.0 | 1,695 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <alibabacloud/oss/model/Tagging.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT ListBucketsRequest: public OssRequest
{
public:
ListBucketsRequest();
ListBucketsRequest(const std::string& prefix, const std::string& marker, int maxKeys = 100);
void setPrefix(const std::string& prefix) {prefix_ = prefix; prefixIsSet_ = true;}
void setMarker(const std::string& marker) {marker_ = marker; markerIsSet_ = true;}
void setMaxKeys(int maxKeys) {maxKeys_ = maxKeys; maxKeysIsSet_ = true;}
void setTag(const Tag& tag) { tag_ = tag; tagIsSet = true; }
protected:
virtual ParameterCollection specialParameters() const;
private:
std::string prefix_;
bool prefixIsSet_;
std::string marker_;
bool markerIsSet_;
int maxKeys_;
bool maxKeysIsSet_;
Tag tag_;
bool tagIsSet;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/ListBucketsRequest.h | C++ | apache-2.0 | 1,675 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include "Bucket.h"
#include <vector>
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT ListBucketsResult: public OssResult
{
public:
ListBucketsResult();
ListBucketsResult(const std::string& data);
ListBucketsResult(const std::shared_ptr<std::iostream>& data);
ListBucketsResult& operator=(const std::string& data);
const std::string& Prefix() const { return prefix_; }
const std::string& Marker() const { return marker_; }
const std::string& NextMarker() const { return nextMarker_; }
int MaxKeys() const { return maxKeys_; }
bool IsTruncated() const { return isTruncated_; }
const std::vector<Bucket>& Buckets() const { return buckets_; }
private:
std::string prefix_;
std::string marker_;
std::string nextMarker_;
bool isTruncated_;
int maxKeys_;
std::vector<Bucket> buckets_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/ListBucketsResult.h | C++ | apache-2.0 | 1,693 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT ListLiveChannelRequest: public OssBucketRequest
{
public:
ListLiveChannelRequest(const std::string &bucket);
void setMarker(const std::string& marker);
void setMaxKeys(uint32_t maxKeys);
void setPrefix(const std::string& prefix);
protected:
virtual ParameterCollection specialParameters() const;
virtual int validate() const;
private:
std::string prefix_;
std::string marker_;
uint32_t maxKeys_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/ListLiveChannelRequest.h | C++ | apache-2.0 | 1,299 |
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <vector>
#include <memory>
#include <iostream>
#include <alibabacloud/oss/OssResult.h>
namespace AlibabaCloud
{
namespace OSS
{
struct LiveChannelInfo
{
std::string name;
std::string description;
std::string status;
std::string lastModified;
std::string publishUrl;
std::string playUrl;
};
using LiveChannelListInfo = std::vector<LiveChannelInfo>;
class ALIBABACLOUD_OSS_EXPORT ListLiveChannelResult: public OssResult
{
public:
ListLiveChannelResult();
ListLiveChannelResult(const std::string& data);
ListLiveChannelResult(const std::shared_ptr<std::iostream>& data);
ListLiveChannelResult& operator=(const std::string& data);
const std::string& Prefix() const;
const std::string& Marker() const;
const std::string& NextMarker() const;
bool IsTruncated() const;
const LiveChannelListInfo& LiveChannelList() const;
uint32_t MaxKeys() const;
private:
std::string prefix_;
std::string marker_;
std::string nextMarker_;
LiveChannelListInfo liveChannelList_;
uint32_t maxKeys_;
bool isTruncated_;
};
}
}
| YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/ListLiveChannelResult.h | C++ | apache-2.0 | 1,879 |
/*
* Copyright 2009-2018 Alibaba Cloud All rights reserved.
*
* 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.
*/
#pragma once
#include <alibabacloud/oss/Export.h>
#include <alibabacloud/oss/OssRequest.h>
#include <sstream>
#include <iostream>
namespace AlibabaCloud
{
namespace OSS
{
class ALIBABACLOUD_OSS_EXPORT ListMultipartUploadsRequest: public OssBucketRequest
{
public:
ListMultipartUploadsRequest(const std::string& bucket);
void setDelimiter(const std::string& delimiter);
void setMaxUploads(uint32_t maxUploads);
void setKeyMarker(const std::string& keyMarker);
void setPrefix(const std::string& prefix);
void setUploadIdMarker(const std::string& uploadIdMarker);
void setEncodingType(const std::string& encodingType);
void setRequestPayer(RequestPayer value);
protected:
virtual ParameterCollection specialParameters() const;
virtual HeaderCollection specialHeaders() const;
private:
std::string delimiter_;
bool delimiterIsSet_;
std::string keyMarker_;
bool keyMarkerIsSet_;
std::string prefix_;
bool prefixIsSet_;
std::string uploadIdMarker_;
bool uploadIdMarkerIsSet_;
std::string encodingType_;
bool encodingTypeIsSet_;
int maxUploads_;
bool maxUploadsIsSet_;
RequestPayer requestPayer_;
};
}
} | YifuLiu/AliOS-Things | components/oss/include/alibabacloud/oss/model/ListMultipartUploadsRequest.h | C++ | apache-2.0 | 1,934 |