1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update DeleteDcdnDomain.

Browse Source
This commit is contained in:
sdk-team
2020-12-17 08:08:52 +00:00
parent e990580a3e
commit 279ad33425
46 changed files with 2475 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2020-12-17 Version: patch
- Update DeleteDcdnDomain.
2020-12-17 Version: patch
- Update DeleteCdnDomain.

36
dcdn/CMakeLists.txt
View File

@@ -41,6 +41,8 @@ set(dcdn_public_header_model
include/alibabacloud/dcdn/model/BatchStopDcdnDomainResult.h
include/alibabacloud/dcdn/model/CreateDcdnCertificateSigningRequestRequest.h
include/alibabacloud/dcdn/model/CreateDcdnCertificateSigningRequestResult.h
include/alibabacloud/dcdn/model/CreateDcdnDomainOfflineLogDeliveryRequest.h
include/alibabacloud/dcdn/model/CreateDcdnDomainOfflineLogDeliveryResult.h
include/alibabacloud/dcdn/model/DeleteDcdnDomainRequest.h
include/alibabacloud/dcdn/model/DeleteDcdnDomainResult.h
include/alibabacloud/dcdn/model/DeleteDcdnIpaDomainRequest.h
@@ -147,6 +149,14 @@ set(dcdn_public_header_model
include/alibabacloud/dcdn/model/DescribeDcdnIpaServiceResult.h
include/alibabacloud/dcdn/model/DescribeDcdnIpaUserDomainsRequest.h
include/alibabacloud/dcdn/model/DescribeDcdnIpaUserDomainsResult.h
include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryRequest.h
include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryResult.h
include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryFieldRequest.h
include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryFieldResult.h
include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryRegionsRequest.h
include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryRegionsResult.h
include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryStatusRequest.h
include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryStatusResult.h
include/alibabacloud/dcdn/model/DescribeDcdnRefreshQuotaRequest.h
include/alibabacloud/dcdn/model/DescribeDcdnRefreshQuotaResult.h
include/alibabacloud/dcdn/model/DescribeDcdnRefreshTasksRequest.h
@@ -165,6 +175,8 @@ set(dcdn_public_header_model
include/alibabacloud/dcdn/model/DescribeDcdnUserBillTypeResult.h
include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsRequest.h
include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsResult.h
include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsByFuncRequest.h
include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsByFuncResult.h
include/alibabacloud/dcdn/model/DescribeDcdnUserQuotaRequest.h
include/alibabacloud/dcdn/model/DescribeDcdnUserQuotaResult.h
include/alibabacloud/dcdn/model/DescribeDcdnUserResourcePackageRequest.h
@@ -179,6 +191,12 @@ set(dcdn_public_header_model
include/alibabacloud/dcdn/model/DescribeUserDcdnIpaStatusResult.h
include/alibabacloud/dcdn/model/DescribeUserDcdnStatusRequest.h
include/alibabacloud/dcdn/model/DescribeUserDcdnStatusResult.h
include/alibabacloud/dcdn/model/DisableDcdnDomainOfflineLogDeliveryRequest.h
include/alibabacloud/dcdn/model/DisableDcdnDomainOfflineLogDeliveryResult.h
include/alibabacloud/dcdn/model/DisableDcdnOfflineLogDeliveryRequest.h
include/alibabacloud/dcdn/model/DisableDcdnOfflineLogDeliveryResult.h
include/alibabacloud/dcdn/model/EnableDcdnDomainOfflineLogDeliveryRequest.h
include/alibabacloud/dcdn/model/EnableDcdnDomainOfflineLogDeliveryResult.h
include/alibabacloud/dcdn/model/ModifyDCdnDomainSchdmByPropertyRequest.h
include/alibabacloud/dcdn/model/ModifyDCdnDomainSchdmByPropertyResult.h
include/alibabacloud/dcdn/model/ModifyDcdnServiceRequest.h
@@ -242,6 +260,8 @@ set(dcdn_src
src/model/BatchStopDcdnDomainResult.cc
src/model/CreateDcdnCertificateSigningRequestRequest.cc
src/model/CreateDcdnCertificateSigningRequestResult.cc
src/model/CreateDcdnDomainOfflineLogDeliveryRequest.cc
src/model/CreateDcdnDomainOfflineLogDeliveryResult.cc
src/model/DeleteDcdnDomainRequest.cc
src/model/DeleteDcdnDomainResult.cc
src/model/DeleteDcdnIpaDomainRequest.cc
@@ -348,6 +368,14 @@ set(dcdn_src
src/model/DescribeDcdnIpaServiceResult.cc
src/model/DescribeDcdnIpaUserDomainsRequest.cc
src/model/DescribeDcdnIpaUserDomainsResult.cc
src/model/DescribeDcdnOfflineLogDeliveryRequest.cc
src/model/DescribeDcdnOfflineLogDeliveryResult.cc
src/model/DescribeDcdnOfflineLogDeliveryFieldRequest.cc
src/model/DescribeDcdnOfflineLogDeliveryFieldResult.cc
src/model/DescribeDcdnOfflineLogDeliveryRegionsRequest.cc
src/model/DescribeDcdnOfflineLogDeliveryRegionsResult.cc
src/model/DescribeDcdnOfflineLogDeliveryStatusRequest.cc
src/model/DescribeDcdnOfflineLogDeliveryStatusResult.cc
src/model/DescribeDcdnRefreshQuotaRequest.cc
src/model/DescribeDcdnRefreshQuotaResult.cc
src/model/DescribeDcdnRefreshTasksRequest.cc
@@ -366,6 +394,8 @@ set(dcdn_src
src/model/DescribeDcdnUserBillTypeResult.cc
src/model/DescribeDcdnUserDomainsRequest.cc
src/model/DescribeDcdnUserDomainsResult.cc
src/model/DescribeDcdnUserDomainsByFuncRequest.cc
src/model/DescribeDcdnUserDomainsByFuncResult.cc
src/model/DescribeDcdnUserQuotaRequest.cc
src/model/DescribeDcdnUserQuotaResult.cc
src/model/DescribeDcdnUserResourcePackageRequest.cc
@@ -380,6 +410,12 @@ set(dcdn_src
src/model/DescribeUserDcdnIpaStatusResult.cc
src/model/DescribeUserDcdnStatusRequest.cc
src/model/DescribeUserDcdnStatusResult.cc
src/model/DisableDcdnDomainOfflineLogDeliveryRequest.cc
src/model/DisableDcdnDomainOfflineLogDeliveryResult.cc
src/model/DisableDcdnOfflineLogDeliveryRequest.cc
src/model/DisableDcdnOfflineLogDeliveryResult.cc
src/model/EnableDcdnDomainOfflineLogDeliveryRequest.cc
src/model/EnableDcdnDomainOfflineLogDeliveryResult.cc
src/model/ModifyDCdnDomainSchdmByPropertyRequest.cc
src/model/ModifyDCdnDomainSchdmByPropertyResult.cc
src/model/ModifyDcdnServiceRequest.cc

72
dcdn/include/alibabacloud/dcdn/DcdnClient.h
View File

@@ -42,6 +42,8 @@
#include "model/BatchStopDcdnDomainResult.h"
#include "model/CreateDcdnCertificateSigningRequestRequest.h"
#include "model/CreateDcdnCertificateSigningRequestResult.h"
#include "model/CreateDcdnDomainOfflineLogDeliveryRequest.h"
#include "model/CreateDcdnDomainOfflineLogDeliveryResult.h"
#include "model/DeleteDcdnDomainRequest.h"
#include "model/DeleteDcdnDomainResult.h"
#include "model/DeleteDcdnIpaDomainRequest.h"
@@ -148,6 +150,14 @@
#include "model/DescribeDcdnIpaServiceResult.h"
#include "model/DescribeDcdnIpaUserDomainsRequest.h"
#include "model/DescribeDcdnIpaUserDomainsResult.h"
#include "model/DescribeDcdnOfflineLogDeliveryRequest.h"
#include "model/DescribeDcdnOfflineLogDeliveryResult.h"
#include "model/DescribeDcdnOfflineLogDeliveryFieldRequest.h"
#include "model/DescribeDcdnOfflineLogDeliveryFieldResult.h"
#include "model/DescribeDcdnOfflineLogDeliveryRegionsRequest.h"
#include "model/DescribeDcdnOfflineLogDeliveryRegionsResult.h"
#include "model/DescribeDcdnOfflineLogDeliveryStatusRequest.h"
#include "model/DescribeDcdnOfflineLogDeliveryStatusResult.h"
#include "model/DescribeDcdnRefreshQuotaRequest.h"
#include "model/DescribeDcdnRefreshQuotaResult.h"
#include "model/DescribeDcdnRefreshTasksRequest.h"
@@ -166,6 +176,8 @@
#include "model/DescribeDcdnUserBillTypeResult.h"
#include "model/DescribeDcdnUserDomainsRequest.h"
#include "model/DescribeDcdnUserDomainsResult.h"
#include "model/DescribeDcdnUserDomainsByFuncRequest.h"
#include "model/DescribeDcdnUserDomainsByFuncResult.h"
#include "model/DescribeDcdnUserQuotaRequest.h"
#include "model/DescribeDcdnUserQuotaResult.h"
#include "model/DescribeDcdnUserResourcePackageRequest.h"
@@ -180,6 +192,12 @@
#include "model/DescribeUserDcdnIpaStatusResult.h"
#include "model/DescribeUserDcdnStatusRequest.h"
#include "model/DescribeUserDcdnStatusResult.h"
#include "model/DisableDcdnDomainOfflineLogDeliveryRequest.h"
#include "model/DisableDcdnDomainOfflineLogDeliveryResult.h"
#include "model/DisableDcdnOfflineLogDeliveryRequest.h"
#include "model/DisableDcdnOfflineLogDeliveryResult.h"
#include "model/EnableDcdnDomainOfflineLogDeliveryRequest.h"
#include "model/EnableDcdnDomainOfflineLogDeliveryResult.h"
#include "model/ModifyDCdnDomainSchdmByPropertyRequest.h"
#include "model/ModifyDCdnDomainSchdmByPropertyResult.h"
#include "model/ModifyDcdnServiceRequest.h"
@@ -259,6 +277,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateDcdnCertificateSigningRequestResult> CreateDcdnCertificateSigningRequestOutcome;
typedef std::future<CreateDcdnCertificateSigningRequestOutcome> CreateDcdnCertificateSigningRequestOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::CreateDcdnCertificateSigningRequestRequest&, const CreateDcdnCertificateSigningRequestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDcdnCertificateSigningRequestAsyncHandler;
typedef Outcome<Error, Model::CreateDcdnDomainOfflineLogDeliveryResult> CreateDcdnDomainOfflineLogDeliveryOutcome;
typedef std::future<CreateDcdnDomainOfflineLogDeliveryOutcome> CreateDcdnDomainOfflineLogDeliveryOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::CreateDcdnDomainOfflineLogDeliveryRequest&, const CreateDcdnDomainOfflineLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDcdnDomainOfflineLogDeliveryAsyncHandler;
typedef Outcome<Error, Model::DeleteDcdnDomainResult> DeleteDcdnDomainOutcome;
typedef std::future<DeleteDcdnDomainOutcome> DeleteDcdnDomainOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DeleteDcdnDomainRequest&, const DeleteDcdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDcdnDomainAsyncHandler;
@@ -418,6 +439,18 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeDcdnIpaUserDomainsResult> DescribeDcdnIpaUserDomainsOutcome;
typedef std::future<DescribeDcdnIpaUserDomainsOutcome> DescribeDcdnIpaUserDomainsOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnIpaUserDomainsRequest&, const DescribeDcdnIpaUserDomainsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnIpaUserDomainsAsyncHandler;
typedef Outcome<Error, Model::DescribeDcdnOfflineLogDeliveryResult> DescribeDcdnOfflineLogDeliveryOutcome;
typedef std::future<DescribeDcdnOfflineLogDeliveryOutcome> DescribeDcdnOfflineLogDeliveryOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnOfflineLogDeliveryRequest&, const DescribeDcdnOfflineLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnOfflineLogDeliveryAsyncHandler;
typedef Outcome<Error, Model::DescribeDcdnOfflineLogDeliveryFieldResult> DescribeDcdnOfflineLogDeliveryFieldOutcome;
typedef std::future<DescribeDcdnOfflineLogDeliveryFieldOutcome> DescribeDcdnOfflineLogDeliveryFieldOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnOfflineLogDeliveryFieldRequest&, const DescribeDcdnOfflineLogDeliveryFieldOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnOfflineLogDeliveryFieldAsyncHandler;
typedef Outcome<Error, Model::DescribeDcdnOfflineLogDeliveryRegionsResult> DescribeDcdnOfflineLogDeliveryRegionsOutcome;
typedef std::future<DescribeDcdnOfflineLogDeliveryRegionsOutcome> DescribeDcdnOfflineLogDeliveryRegionsOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnOfflineLogDeliveryRegionsRequest&, const DescribeDcdnOfflineLogDeliveryRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnOfflineLogDeliveryRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeDcdnOfflineLogDeliveryStatusResult> DescribeDcdnOfflineLogDeliveryStatusOutcome;
typedef std::future<DescribeDcdnOfflineLogDeliveryStatusOutcome> DescribeDcdnOfflineLogDeliveryStatusOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnOfflineLogDeliveryStatusRequest&, const DescribeDcdnOfflineLogDeliveryStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnOfflineLogDeliveryStatusAsyncHandler;
typedef Outcome<Error, Model::DescribeDcdnRefreshQuotaResult> DescribeDcdnRefreshQuotaOutcome;
typedef std::future<DescribeDcdnRefreshQuotaOutcome> DescribeDcdnRefreshQuotaOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnRefreshQuotaRequest&, const DescribeDcdnRefreshQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnRefreshQuotaAsyncHandler;
@@ -445,6 +478,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeDcdnUserDomainsResult> DescribeDcdnUserDomainsOutcome;
typedef std::future<DescribeDcdnUserDomainsOutcome> DescribeDcdnUserDomainsOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserDomainsRequest&, const DescribeDcdnUserDomainsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserDomainsAsyncHandler;
typedef Outcome<Error, Model::DescribeDcdnUserDomainsByFuncResult> DescribeDcdnUserDomainsByFuncOutcome;
typedef std::future<DescribeDcdnUserDomainsByFuncOutcome> DescribeDcdnUserDomainsByFuncOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserDomainsByFuncRequest&, const DescribeDcdnUserDomainsByFuncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserDomainsByFuncAsyncHandler;
typedef Outcome<Error, Model::DescribeDcdnUserQuotaResult> DescribeDcdnUserQuotaOutcome;
typedef std::future<DescribeDcdnUserQuotaOutcome> DescribeDcdnUserQuotaOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserQuotaRequest&, const DescribeDcdnUserQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserQuotaAsyncHandler;
@@ -466,6 +502,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeUserDcdnStatusResult> DescribeUserDcdnStatusOutcome;
typedef std::future<DescribeUserDcdnStatusOutcome> DescribeUserDcdnStatusOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DescribeUserDcdnStatusRequest&, const DescribeUserDcdnStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserDcdnStatusAsyncHandler;
typedef Outcome<Error, Model::DisableDcdnDomainOfflineLogDeliveryResult> DisableDcdnDomainOfflineLogDeliveryOutcome;
typedef std::future<DisableDcdnDomainOfflineLogDeliveryOutcome> DisableDcdnDomainOfflineLogDeliveryOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DisableDcdnDomainOfflineLogDeliveryRequest&, const DisableDcdnDomainOfflineLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableDcdnDomainOfflineLogDeliveryAsyncHandler;
typedef Outcome<Error, Model::DisableDcdnOfflineLogDeliveryResult> DisableDcdnOfflineLogDeliveryOutcome;
typedef std::future<DisableDcdnOfflineLogDeliveryOutcome> DisableDcdnOfflineLogDeliveryOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::DisableDcdnOfflineLogDeliveryRequest&, const DisableDcdnOfflineLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableDcdnOfflineLogDeliveryAsyncHandler;
typedef Outcome<Error, Model::EnableDcdnDomainOfflineLogDeliveryResult> EnableDcdnDomainOfflineLogDeliveryOutcome;
typedef std::future<EnableDcdnDomainOfflineLogDeliveryOutcome> EnableDcdnDomainOfflineLogDeliveryOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::EnableDcdnDomainOfflineLogDeliveryRequest&, const EnableDcdnDomainOfflineLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableDcdnDomainOfflineLogDeliveryAsyncHandler;
typedef Outcome<Error, Model::ModifyDCdnDomainSchdmByPropertyResult> ModifyDCdnDomainSchdmByPropertyOutcome;
typedef std::future<ModifyDCdnDomainSchdmByPropertyOutcome> ModifyDCdnDomainSchdmByPropertyOutcomeCallable;
typedef std::function<void(const DcdnClient*, const Model::ModifyDCdnDomainSchdmByPropertyRequest&, const ModifyDCdnDomainSchdmByPropertyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDCdnDomainSchdmByPropertyAsyncHandler;
@@ -561,6 +606,9 @@ namespace AlibabaCloud
CreateDcdnCertificateSigningRequestOutcome createDcdnCertificateSigningRequest(const Model::CreateDcdnCertificateSigningRequestRequest &request)const;
void createDcdnCertificateSigningRequestAsync(const Model::CreateDcdnCertificateSigningRequestRequest& request, const CreateDcdnCertificateSigningRequestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDcdnCertificateSigningRequestOutcomeCallable createDcdnCertificateSigningRequestCallable(const Model::CreateDcdnCertificateSigningRequestRequest& request) const;
CreateDcdnDomainOfflineLogDeliveryOutcome createDcdnDomainOfflineLogDelivery(const Model::CreateDcdnDomainOfflineLogDeliveryRequest &request)const;
void createDcdnDomainOfflineLogDeliveryAsync(const Model::CreateDcdnDomainOfflineLogDeliveryRequest& request, const CreateDcdnDomainOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDcdnDomainOfflineLogDeliveryOutcomeCallable createDcdnDomainOfflineLogDeliveryCallable(const Model::CreateDcdnDomainOfflineLogDeliveryRequest& request) const;
DeleteDcdnDomainOutcome deleteDcdnDomain(const Model::DeleteDcdnDomainRequest &request)const;
void deleteDcdnDomainAsync(const Model::DeleteDcdnDomainRequest& request, const DeleteDcdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDcdnDomainOutcomeCallable deleteDcdnDomainCallable(const Model::DeleteDcdnDomainRequest& request) const;
@@ -720,6 +768,18 @@ namespace AlibabaCloud
DescribeDcdnIpaUserDomainsOutcome describeDcdnIpaUserDomains(const Model::DescribeDcdnIpaUserDomainsRequest &request)const;
void describeDcdnIpaUserDomainsAsync(const Model::DescribeDcdnIpaUserDomainsRequest& request, const DescribeDcdnIpaUserDomainsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDcdnIpaUserDomainsOutcomeCallable describeDcdnIpaUserDomainsCallable(const Model::DescribeDcdnIpaUserDomainsRequest& request) const;
DescribeDcdnOfflineLogDeliveryOutcome describeDcdnOfflineLogDelivery(const Model::DescribeDcdnOfflineLogDeliveryRequest &request)const;
void describeDcdnOfflineLogDeliveryAsync(const Model::DescribeDcdnOfflineLogDeliveryRequest& request, const DescribeDcdnOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDcdnOfflineLogDeliveryOutcomeCallable describeDcdnOfflineLogDeliveryCallable(const Model::DescribeDcdnOfflineLogDeliveryRequest& request) const;
DescribeDcdnOfflineLogDeliveryFieldOutcome describeDcdnOfflineLogDeliveryField(const Model::DescribeDcdnOfflineLogDeliveryFieldRequest &request)const;
void describeDcdnOfflineLogDeliveryFieldAsync(const Model::DescribeDcdnOfflineLogDeliveryFieldRequest& request, const DescribeDcdnOfflineLogDeliveryFieldAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDcdnOfflineLogDeliveryFieldOutcomeCallable describeDcdnOfflineLogDeliveryFieldCallable(const Model::DescribeDcdnOfflineLogDeliveryFieldRequest& request) const;
DescribeDcdnOfflineLogDeliveryRegionsOutcome describeDcdnOfflineLogDeliveryRegions(const Model::DescribeDcdnOfflineLogDeliveryRegionsRequest &request)const;
void describeDcdnOfflineLogDeliveryRegionsAsync(const Model::DescribeDcdnOfflineLogDeliveryRegionsRequest& request, const DescribeDcdnOfflineLogDeliveryRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDcdnOfflineLogDeliveryRegionsOutcomeCallable describeDcdnOfflineLogDeliveryRegionsCallable(const Model::DescribeDcdnOfflineLogDeliveryRegionsRequest& request) const;
DescribeDcdnOfflineLogDeliveryStatusOutcome describeDcdnOfflineLogDeliveryStatus(const Model::DescribeDcdnOfflineLogDeliveryStatusRequest &request)const;
void describeDcdnOfflineLogDeliveryStatusAsync(const Model::DescribeDcdnOfflineLogDeliveryStatusRequest& request, const DescribeDcdnOfflineLogDeliveryStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDcdnOfflineLogDeliveryStatusOutcomeCallable describeDcdnOfflineLogDeliveryStatusCallable(const Model::DescribeDcdnOfflineLogDeliveryStatusRequest& request) const;
DescribeDcdnRefreshQuotaOutcome describeDcdnRefreshQuota(const Model::DescribeDcdnRefreshQuotaRequest &request)const;
void describeDcdnRefreshQuotaAsync(const Model::DescribeDcdnRefreshQuotaRequest& request, const DescribeDcdnRefreshQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDcdnRefreshQuotaOutcomeCallable describeDcdnRefreshQuotaCallable(const Model::DescribeDcdnRefreshQuotaRequest& request) const;
@@ -747,6 +807,9 @@ namespace AlibabaCloud
DescribeDcdnUserDomainsOutcome describeDcdnUserDomains(const Model::DescribeDcdnUserDomainsRequest &request)const;
void describeDcdnUserDomainsAsync(const Model::DescribeDcdnUserDomainsRequest& request, const DescribeDcdnUserDomainsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDcdnUserDomainsOutcomeCallable describeDcdnUserDomainsCallable(const Model::DescribeDcdnUserDomainsRequest& request) const;
DescribeDcdnUserDomainsByFuncOutcome describeDcdnUserDomainsByFunc(const Model::DescribeDcdnUserDomainsByFuncRequest &request)const;
void describeDcdnUserDomainsByFuncAsync(const Model::DescribeDcdnUserDomainsByFuncRequest& request, const DescribeDcdnUserDomainsByFuncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDcdnUserDomainsByFuncOutcomeCallable describeDcdnUserDomainsByFuncCallable(const Model::DescribeDcdnUserDomainsByFuncRequest& request) const;
DescribeDcdnUserQuotaOutcome describeDcdnUserQuota(const Model::DescribeDcdnUserQuotaRequest &request)const;
void describeDcdnUserQuotaAsync(const Model::DescribeDcdnUserQuotaRequest& request, const DescribeDcdnUserQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDcdnUserQuotaOutcomeCallable describeDcdnUserQuotaCallable(const Model::DescribeDcdnUserQuotaRequest& request) const;
@@ -768,6 +831,15 @@ namespace AlibabaCloud
DescribeUserDcdnStatusOutcome describeUserDcdnStatus(const Model::DescribeUserDcdnStatusRequest &request)const;
void describeUserDcdnStatusAsync(const Model::DescribeUserDcdnStatusRequest& request, const DescribeUserDcdnStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeUserDcdnStatusOutcomeCallable describeUserDcdnStatusCallable(const Model::DescribeUserDcdnStatusRequest& request) const;
DisableDcdnDomainOfflineLogDeliveryOutcome disableDcdnDomainOfflineLogDelivery(const Model::DisableDcdnDomainOfflineLogDeliveryRequest &request)const;
void disableDcdnDomainOfflineLogDeliveryAsync(const Model::DisableDcdnDomainOfflineLogDeliveryRequest& request, const DisableDcdnDomainOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableDcdnDomainOfflineLogDeliveryOutcomeCallable disableDcdnDomainOfflineLogDeliveryCallable(const Model::DisableDcdnDomainOfflineLogDeliveryRequest& request) const;
DisableDcdnOfflineLogDeliveryOutcome disableDcdnOfflineLogDelivery(const Model::DisableDcdnOfflineLogDeliveryRequest &request)const;
void disableDcdnOfflineLogDeliveryAsync(const Model::DisableDcdnOfflineLogDeliveryRequest& request, const DisableDcdnOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableDcdnOfflineLogDeliveryOutcomeCallable disableDcdnOfflineLogDeliveryCallable(const Model::DisableDcdnOfflineLogDeliveryRequest& request) const;
EnableDcdnDomainOfflineLogDeliveryOutcome enableDcdnDomainOfflineLogDelivery(const Model::EnableDcdnDomainOfflineLogDeliveryRequest &request)const;
void enableDcdnDomainOfflineLogDeliveryAsync(const Model::EnableDcdnDomainOfflineLogDeliveryRequest& request, const EnableDcdnDomainOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableDcdnDomainOfflineLogDeliveryOutcomeCallable enableDcdnDomainOfflineLogDeliveryCallable(const Model::EnableDcdnDomainOfflineLogDeliveryRequest& request) const;
ModifyDCdnDomainSchdmByPropertyOutcome modifyDCdnDomainSchdmByProperty(const Model::ModifyDCdnDomainSchdmByPropertyRequest &request)const;
void modifyDCdnDomainSchdmByPropertyAsync(const Model::ModifyDCdnDomainSchdmByPropertyRequest& request, const ModifyDCdnDomainSchdmByPropertyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDCdnDomainSchdmByPropertyOutcomeCallable modifyDCdnDomainSchdmByPropertyCallable(const Model::ModifyDCdnDomainSchdmByPropertyRequest& request) const;

57
dcdn/include/alibabacloud/dcdn/model/CreateDcdnDomainOfflineLogDeliveryRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_CREATEDCDNDOMAINOFFLINELOGDELIVERYREQUEST_H_
#define ALIBABACLOUD_DCDN_MODEL_CREATEDCDNDOMAINOFFLINELOGDELIVERYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT CreateDcdnDomainOfflineLogDeliveryRequest : public RpcServiceRequest
{
public:
CreateDcdnDomainOfflineLogDeliveryRequest();
~CreateDcdnDomainOfflineLogDeliveryRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getFieldId()const;
void setFieldId(const std::string& fieldId);
private:
std::string regionId_;
std::string domainName_;
long ownerId_;
std::string fieldId_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_CREATEDCDNDOMAINOFFLINELOGDELIVERYREQUEST_H_

49
dcdn/include/alibabacloud/dcdn/model/CreateDcdnDomainOfflineLogDeliveryResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_CREATEDCDNDOMAINOFFLINELOGDELIVERYRESULT_H_
#define ALIBABACLOUD_DCDN_MODEL_CREATEDCDNDOMAINOFFLINELOGDELIVERYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT CreateDcdnDomainOfflineLogDeliveryResult : public ServiceResult
{
public:
CreateDcdnDomainOfflineLogDeliveryResult();
explicit CreateDcdnDomainOfflineLogDeliveryResult(const std::string &payload);
~CreateDcdnDomainOfflineLogDeliveryResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_CREATEDCDNDOMAINOFFLINELOGDELIVERYRESULT_H_

3
dcdn/include/alibabacloud/dcdn/model/DeleteDcdnDomainRequest.h
View File

@@ -41,8 +41,6 @@ namespace AlibabaCloud
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
@@ -50,7 +48,6 @@ namespace AlibabaCloud
std::string ownerAccount_;
std::string domainName_;
long ownerId_;
std::string resourceGroupId_;
std::string securityToken_;
};

9
dcdn/include/alibabacloud/dcdn/model/DeleteDcdnIpaDomainRequest.h
View File

@@ -35,23 +35,20 @@ namespace AlibabaCloud
DeleteDcdnIpaDomainRequest();
~DeleteDcdnIpaDomainRequest();
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
private:
std::string resourceGroupId_;
std::string securityToken_;
std::string ownerAccount_;
std::string domainName_;
long ownerId_;
std::string securityToken_;
};
}

9
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainTopReferVisitRequest.h
View File

@@ -35,22 +35,19 @@ namespace AlibabaCloud
DescribeDcdnDomainTopReferVisitRequest();
~DescribeDcdnDomainTopReferVisitRequest();
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getSortBy()const;
void setSortBy(const std::string& sortBy);
private:
std::string domainName_;
std::string startTime_;
std::string domainName_;
long ownerId_;
std::string securityToken_;
std::string sortBy_;
};

48
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryFieldRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYFIELDREQUEST_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYFIELDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnOfflineLogDeliveryFieldRequest : public RpcServiceRequest
{
public:
DescribeDcdnOfflineLogDeliveryFieldRequest();
~DescribeDcdnOfflineLogDeliveryFieldRequest();
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYFIELDREQUEST_H_

57
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryFieldResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYFIELDRESULT_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYFIELDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnOfflineLogDeliveryFieldResult : public ServiceResult
{
public:
struct Field
{
std::string description;
std::string fieldId;
std::string fieldName;
};
DescribeDcdnOfflineLogDeliveryFieldResult();
explicit DescribeDcdnOfflineLogDeliveryFieldResult(const std::string &payload);
~DescribeDcdnOfflineLogDeliveryFieldResult();
std::vector<Field> getFields()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Field> fields_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYFIELDRESULT_H_

48
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryRegionsRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYREGIONSREQUEST_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnOfflineLogDeliveryRegionsRequest : public RpcServiceRequest
{
public:
DescribeDcdnOfflineLogDeliveryRegionsRequest();
~DescribeDcdnOfflineLogDeliveryRegionsRequest();
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYREGIONSREQUEST_H_

64
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryRegionsResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYREGIONSRESULT_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnOfflineLogDeliveryRegionsResult : public ServiceResult
{
public:
struct Area
{
struct RegionInfo
{
std::string isOverseas;
std::string ossEndpoint;
std::string regionName;
std::string regionId;
};
std::string areaName;
std::string areaId;
std::vector<Area::RegionInfo> regionInfos;
};
DescribeDcdnOfflineLogDeliveryRegionsResult();
explicit DescribeDcdnOfflineLogDeliveryRegionsResult(const std::string &payload);
~DescribeDcdnOfflineLogDeliveryRegionsResult();
std::vector<Area> getAreas()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Area> areas_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYREGIONSRESULT_H_

48
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYREQUEST_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnOfflineLogDeliveryRequest : public RpcServiceRequest
{
public:
DescribeDcdnOfflineLogDeliveryRequest();
~DescribeDcdnOfflineLogDeliveryRequest();
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYREQUEST_H_

74
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryResult.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYRESULT_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnOfflineLogDeliveryResult : public ServiceResult
{
public:
struct Domain
{
std::string domainName;
};
struct Region
{
std::string dlaVcName;
std::string areaName;
std::string ossPathPrefix;
std::string isOverseas;
std::string ossEndpoint;
int ossId;
std::string regionName;
std::string dlaTableName;
std::string areaId;
std::string ossBucketName;
std::string regionId;
std::string dlaDbName;
};
DescribeDcdnOfflineLogDeliveryResult();
explicit DescribeDcdnOfflineLogDeliveryResult(const std::string &payload);
~DescribeDcdnOfflineLogDeliveryResult();
std::vector<Domain> getDomains()const;
std::vector<std::string> getFields()const;
std::vector<Region> getRegions()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Domain> domains_;
std::vector<std::string> fields_;
std::vector<Region> regions_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYRESULT_H_

48
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryStatusRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYSTATUSREQUEST_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYSTATUSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnOfflineLogDeliveryStatusRequest : public RpcServiceRequest
{
public:
DescribeDcdnOfflineLogDeliveryStatusRequest();
~DescribeDcdnOfflineLogDeliveryStatusRequest();
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYSTATUSREQUEST_H_

51
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryStatusResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYSTATUSRESULT_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYSTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnOfflineLogDeliveryStatusResult : public ServiceResult
{
public:
DescribeDcdnOfflineLogDeliveryStatusResult();
explicit DescribeDcdnOfflineLogDeliveryStatusResult(const std::string &payload);
~DescribeDcdnOfflineLogDeliveryStatusResult();
std::string getOpenStatus()const;
protected:
void parse(const std::string &payload);
private:
std::string openStatus_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNOFFLINELOGDELIVERYSTATUSRESULT_H_

60
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsByFuncRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERDOMAINSBYFUNCREQUEST_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERDOMAINSBYFUNCREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnUserDomainsByFuncRequest : public RpcServiceRequest
{
public:
DescribeDcdnUserDomainsByFuncRequest();
~DescribeDcdnUserDomainsByFuncRequest();
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
int getPageSize()const;
void setPageSize(int pageSize);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getFuncId()const;
void setFuncId(int funcId);
private:
int pageNumber_;
std::string resourceGroupId_;
int pageSize_;
long ownerId_;
int funcId_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERDOMAINSBYFUNCREQUEST_H_

79
dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsByFuncResult.h Normal file
View File

@@ -0,0 +1,79 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERDOMAINSBYFUNCRESULT_H_
#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERDOMAINSBYFUNCRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnUserDomainsByFuncResult : public ServiceResult
{
public:
struct PageData
{
struct Source
{
std::string type;
std::string content;
std::string priority;
int port;
std::string weight;
};
std::string description;
std::string sslProtocol;
std::string resourceGroupId;
std::string domainName;
std::string gmtModified;
std::string cdnType;
std::string gmtCreated;
std::vector<PageData::Source> sources;
std::string cname;
std::string domainStatus;
std::string sandbox;
};
DescribeDcdnUserDomainsByFuncResult();
explicit DescribeDcdnUserDomainsByFuncResult(const std::string &payload);
~DescribeDcdnUserDomainsByFuncResult();
std::vector<PageData> getDomains()const;
long getTotalCount()const;
long getPageSize()const;
long getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
std::vector<PageData> domains_;
long totalCount_;
long pageSize_;
long pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERDOMAINSBYFUNCRESULT_H_

51
dcdn/include/alibabacloud/dcdn/model/DisableDcdnDomainOfflineLogDeliveryRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNDOMAINOFFLINELOGDELIVERYREQUEST_H_
#define ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNDOMAINOFFLINELOGDELIVERYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DisableDcdnDomainOfflineLogDeliveryRequest : public RpcServiceRequest
{
public:
DisableDcdnDomainOfflineLogDeliveryRequest();
~DisableDcdnDomainOfflineLogDeliveryRequest();
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNDOMAINOFFLINELOGDELIVERYREQUEST_H_

49
dcdn/include/alibabacloud/dcdn/model/DisableDcdnDomainOfflineLogDeliveryResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNDOMAINOFFLINELOGDELIVERYRESULT_H_
#define ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNDOMAINOFFLINELOGDELIVERYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DisableDcdnDomainOfflineLogDeliveryResult : public ServiceResult
{
public:
DisableDcdnDomainOfflineLogDeliveryResult();
explicit DisableDcdnDomainOfflineLogDeliveryResult(const std::string &payload);
~DisableDcdnDomainOfflineLogDeliveryResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNDOMAINOFFLINELOGDELIVERYRESULT_H_

48
dcdn/include/alibabacloud/dcdn/model/DisableDcdnOfflineLogDeliveryRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNOFFLINELOGDELIVERYREQUEST_H_
#define ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNOFFLINELOGDELIVERYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DisableDcdnOfflineLogDeliveryRequest : public RpcServiceRequest
{
public:
DisableDcdnOfflineLogDeliveryRequest();
~DisableDcdnOfflineLogDeliveryRequest();
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNOFFLINELOGDELIVERYREQUEST_H_

49
dcdn/include/alibabacloud/dcdn/model/DisableDcdnOfflineLogDeliveryResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNOFFLINELOGDELIVERYRESULT_H_
#define ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNOFFLINELOGDELIVERYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT DisableDcdnOfflineLogDeliveryResult : public ServiceResult
{
public:
DisableDcdnOfflineLogDeliveryResult();
explicit DisableDcdnOfflineLogDeliveryResult(const std::string &payload);
~DisableDcdnOfflineLogDeliveryResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_DISABLEDCDNOFFLINELOGDELIVERYRESULT_H_

51
dcdn/include/alibabacloud/dcdn/model/EnableDcdnDomainOfflineLogDeliveryRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_ENABLEDCDNDOMAINOFFLINELOGDELIVERYREQUEST_H_
#define ALIBABACLOUD_DCDN_MODEL_ENABLEDCDNDOMAINOFFLINELOGDELIVERYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT EnableDcdnDomainOfflineLogDeliveryRequest : public RpcServiceRequest
{
public:
EnableDcdnDomainOfflineLogDeliveryRequest();
~EnableDcdnDomainOfflineLogDeliveryRequest();
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_ENABLEDCDNDOMAINOFFLINELOGDELIVERYREQUEST_H_

49
dcdn/include/alibabacloud/dcdn/model/EnableDcdnDomainOfflineLogDeliveryResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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.
*/
#ifndef ALIBABACLOUD_DCDN_MODEL_ENABLEDCDNDOMAINOFFLINELOGDELIVERYRESULT_H_
#define ALIBABACLOUD_DCDN_MODEL_ENABLEDCDNDOMAINOFFLINELOGDELIVERYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/dcdn/DcdnExport.h>
namespace AlibabaCloud
{
namespace Dcdn
{
namespace Model
{
class ALIBABACLOUD_DCDN_EXPORT EnableDcdnDomainOfflineLogDeliveryResult : public ServiceResult
{
public:
EnableDcdnDomainOfflineLogDeliveryResult();
explicit EnableDcdnDomainOfflineLogDeliveryResult(const std::string &payload);
~EnableDcdnDomainOfflineLogDeliveryResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_DCDN_MODEL_ENABLEDCDNDOMAINOFFLINELOGDELIVERYRESULT_H_

324
dcdn/src/DcdnClient.cc
View File

@@ -411,6 +411,42 @@ DcdnClient::CreateDcdnCertificateSigningRequestOutcomeCallable DcdnClient::creat
return task->get_future();
}
DcdnClient::CreateDcdnDomainOfflineLogDeliveryOutcome DcdnClient::createDcdnDomainOfflineLogDelivery(const CreateDcdnDomainOfflineLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDcdnDomainOfflineLogDeliveryOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDcdnDomainOfflineLogDeliveryOutcome(CreateDcdnDomainOfflineLogDeliveryResult(outcome.result()));
else
return CreateDcdnDomainOfflineLogDeliveryOutcome(outcome.error());
}
void DcdnClient::createDcdnDomainOfflineLogDeliveryAsync(const CreateDcdnDomainOfflineLogDeliveryRequest& request, const CreateDcdnDomainOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDcdnDomainOfflineLogDelivery(request), context);
};
asyncExecute(new Runnable(fn));
}
DcdnClient::CreateDcdnDomainOfflineLogDeliveryOutcomeCallable DcdnClient::createDcdnDomainOfflineLogDeliveryCallable(const CreateDcdnDomainOfflineLogDeliveryRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDcdnDomainOfflineLogDeliveryOutcome()>>(
[this, request]()
{
return this->createDcdnDomainOfflineLogDelivery(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DcdnClient::DeleteDcdnDomainOutcome DcdnClient::deleteDcdnDomain(const DeleteDcdnDomainRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2319,6 +2355,150 @@ DcdnClient::DescribeDcdnIpaUserDomainsOutcomeCallable DcdnClient::describeDcdnIp
return task->get_future();
}
DcdnClient::DescribeDcdnOfflineLogDeliveryOutcome DcdnClient::describeDcdnOfflineLogDelivery(const DescribeDcdnOfflineLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDcdnOfflineLogDeliveryOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDcdnOfflineLogDeliveryOutcome(DescribeDcdnOfflineLogDeliveryResult(outcome.result()));
else
return DescribeDcdnOfflineLogDeliveryOutcome(outcome.error());
}
void DcdnClient::describeDcdnOfflineLogDeliveryAsync(const DescribeDcdnOfflineLogDeliveryRequest& request, const DescribeDcdnOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDcdnOfflineLogDelivery(request), context);
};
asyncExecute(new Runnable(fn));
}
DcdnClient::DescribeDcdnOfflineLogDeliveryOutcomeCallable DcdnClient::describeDcdnOfflineLogDeliveryCallable(const DescribeDcdnOfflineLogDeliveryRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDcdnOfflineLogDeliveryOutcome()>>(
[this, request]()
{
return this->describeDcdnOfflineLogDelivery(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DcdnClient::DescribeDcdnOfflineLogDeliveryFieldOutcome DcdnClient::describeDcdnOfflineLogDeliveryField(const DescribeDcdnOfflineLogDeliveryFieldRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDcdnOfflineLogDeliveryFieldOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDcdnOfflineLogDeliveryFieldOutcome(DescribeDcdnOfflineLogDeliveryFieldResult(outcome.result()));
else
return DescribeDcdnOfflineLogDeliveryFieldOutcome(outcome.error());
}
void DcdnClient::describeDcdnOfflineLogDeliveryFieldAsync(const DescribeDcdnOfflineLogDeliveryFieldRequest& request, const DescribeDcdnOfflineLogDeliveryFieldAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDcdnOfflineLogDeliveryField(request), context);
};
asyncExecute(new Runnable(fn));
}
DcdnClient::DescribeDcdnOfflineLogDeliveryFieldOutcomeCallable DcdnClient::describeDcdnOfflineLogDeliveryFieldCallable(const DescribeDcdnOfflineLogDeliveryFieldRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDcdnOfflineLogDeliveryFieldOutcome()>>(
[this, request]()
{
return this->describeDcdnOfflineLogDeliveryField(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DcdnClient::DescribeDcdnOfflineLogDeliveryRegionsOutcome DcdnClient::describeDcdnOfflineLogDeliveryRegions(const DescribeDcdnOfflineLogDeliveryRegionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDcdnOfflineLogDeliveryRegionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDcdnOfflineLogDeliveryRegionsOutcome(DescribeDcdnOfflineLogDeliveryRegionsResult(outcome.result()));
else
return DescribeDcdnOfflineLogDeliveryRegionsOutcome(outcome.error());
}
void DcdnClient::describeDcdnOfflineLogDeliveryRegionsAsync(const DescribeDcdnOfflineLogDeliveryRegionsRequest& request, const DescribeDcdnOfflineLogDeliveryRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDcdnOfflineLogDeliveryRegions(request), context);
};
asyncExecute(new Runnable(fn));
}
DcdnClient::DescribeDcdnOfflineLogDeliveryRegionsOutcomeCallable DcdnClient::describeDcdnOfflineLogDeliveryRegionsCallable(const DescribeDcdnOfflineLogDeliveryRegionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDcdnOfflineLogDeliveryRegionsOutcome()>>(
[this, request]()
{
return this->describeDcdnOfflineLogDeliveryRegions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DcdnClient::DescribeDcdnOfflineLogDeliveryStatusOutcome DcdnClient::describeDcdnOfflineLogDeliveryStatus(const DescribeDcdnOfflineLogDeliveryStatusRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDcdnOfflineLogDeliveryStatusOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDcdnOfflineLogDeliveryStatusOutcome(DescribeDcdnOfflineLogDeliveryStatusResult(outcome.result()));
else
return DescribeDcdnOfflineLogDeliveryStatusOutcome(outcome.error());
}
void DcdnClient::describeDcdnOfflineLogDeliveryStatusAsync(const DescribeDcdnOfflineLogDeliveryStatusRequest& request, const DescribeDcdnOfflineLogDeliveryStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDcdnOfflineLogDeliveryStatus(request), context);
};
asyncExecute(new Runnable(fn));
}
DcdnClient::DescribeDcdnOfflineLogDeliveryStatusOutcomeCallable DcdnClient::describeDcdnOfflineLogDeliveryStatusCallable(const DescribeDcdnOfflineLogDeliveryStatusRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDcdnOfflineLogDeliveryStatusOutcome()>>(
[this, request]()
{
return this->describeDcdnOfflineLogDeliveryStatus(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DcdnClient::DescribeDcdnRefreshQuotaOutcome DcdnClient::describeDcdnRefreshQuota(const DescribeDcdnRefreshQuotaRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2643,6 +2823,42 @@ DcdnClient::DescribeDcdnUserDomainsOutcomeCallable DcdnClient::describeDcdnUserD
return task->get_future();
}
DcdnClient::DescribeDcdnUserDomainsByFuncOutcome DcdnClient::describeDcdnUserDomainsByFunc(const DescribeDcdnUserDomainsByFuncRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDcdnUserDomainsByFuncOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDcdnUserDomainsByFuncOutcome(DescribeDcdnUserDomainsByFuncResult(outcome.result()));
else
return DescribeDcdnUserDomainsByFuncOutcome(outcome.error());
}
void DcdnClient::describeDcdnUserDomainsByFuncAsync(const DescribeDcdnUserDomainsByFuncRequest& request, const DescribeDcdnUserDomainsByFuncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDcdnUserDomainsByFunc(request), context);
};
asyncExecute(new Runnable(fn));
}
DcdnClient::DescribeDcdnUserDomainsByFuncOutcomeCallable DcdnClient::describeDcdnUserDomainsByFuncCallable(const DescribeDcdnUserDomainsByFuncRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDcdnUserDomainsByFuncOutcome()>>(
[this, request]()
{
return this->describeDcdnUserDomainsByFunc(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DcdnClient::DescribeDcdnUserQuotaOutcome DcdnClient::describeDcdnUserQuota(const DescribeDcdnUserQuotaRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2895,6 +3111,114 @@ DcdnClient::DescribeUserDcdnStatusOutcomeCallable DcdnClient::describeUserDcdnSt
return task->get_future();
}
DcdnClient::DisableDcdnDomainOfflineLogDeliveryOutcome DcdnClient::disableDcdnDomainOfflineLogDelivery(const DisableDcdnDomainOfflineLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DisableDcdnDomainOfflineLogDeliveryOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DisableDcdnDomainOfflineLogDeliveryOutcome(DisableDcdnDomainOfflineLogDeliveryResult(outcome.result()));
else
return DisableDcdnDomainOfflineLogDeliveryOutcome(outcome.error());
}
void DcdnClient::disableDcdnDomainOfflineLogDeliveryAsync(const DisableDcdnDomainOfflineLogDeliveryRequest& request, const DisableDcdnDomainOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, disableDcdnDomainOfflineLogDelivery(request), context);
};
asyncExecute(new Runnable(fn));
}
DcdnClient::DisableDcdnDomainOfflineLogDeliveryOutcomeCallable DcdnClient::disableDcdnDomainOfflineLogDeliveryCallable(const DisableDcdnDomainOfflineLogDeliveryRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DisableDcdnDomainOfflineLogDeliveryOutcome()>>(
[this, request]()
{
return this->disableDcdnDomainOfflineLogDelivery(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DcdnClient::DisableDcdnOfflineLogDeliveryOutcome DcdnClient::disableDcdnOfflineLogDelivery(const DisableDcdnOfflineLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DisableDcdnOfflineLogDeliveryOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DisableDcdnOfflineLogDeliveryOutcome(DisableDcdnOfflineLogDeliveryResult(outcome.result()));
else
return DisableDcdnOfflineLogDeliveryOutcome(outcome.error());
}
void DcdnClient::disableDcdnOfflineLogDeliveryAsync(const DisableDcdnOfflineLogDeliveryRequest& request, const DisableDcdnOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, disableDcdnOfflineLogDelivery(request), context);
};
asyncExecute(new Runnable(fn));
}
DcdnClient::DisableDcdnOfflineLogDeliveryOutcomeCallable DcdnClient::disableDcdnOfflineLogDeliveryCallable(const DisableDcdnOfflineLogDeliveryRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DisableDcdnOfflineLogDeliveryOutcome()>>(
[this, request]()
{
return this->disableDcdnOfflineLogDelivery(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DcdnClient::EnableDcdnDomainOfflineLogDeliveryOutcome DcdnClient::enableDcdnDomainOfflineLogDelivery(const EnableDcdnDomainOfflineLogDeliveryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EnableDcdnDomainOfflineLogDeliveryOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EnableDcdnDomainOfflineLogDeliveryOutcome(EnableDcdnDomainOfflineLogDeliveryResult(outcome.result()));
else
return EnableDcdnDomainOfflineLogDeliveryOutcome(outcome.error());
}
void DcdnClient::enableDcdnDomainOfflineLogDeliveryAsync(const EnableDcdnDomainOfflineLogDeliveryRequest& request, const EnableDcdnDomainOfflineLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, enableDcdnDomainOfflineLogDelivery(request), context);
};
asyncExecute(new Runnable(fn));
}
DcdnClient::EnableDcdnDomainOfflineLogDeliveryOutcomeCallable DcdnClient::enableDcdnDomainOfflineLogDeliveryCallable(const EnableDcdnDomainOfflineLogDeliveryRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EnableDcdnDomainOfflineLogDeliveryOutcome()>>(
[this, request]()
{
return this->enableDcdnDomainOfflineLogDelivery(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DcdnClient::ModifyDCdnDomainSchdmByPropertyOutcome DcdnClient::modifyDCdnDomainSchdmByProperty(const ModifyDCdnDomainSchdmByPropertyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

73
dcdn/src/model/CreateDcdnDomainOfflineLogDeliveryRequest.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* 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 <alibabacloud/dcdn/model/CreateDcdnDomainOfflineLogDeliveryRequest.h>
using AlibabaCloud::Dcdn::Model::CreateDcdnDomainOfflineLogDeliveryRequest;
CreateDcdnDomainOfflineLogDeliveryRequest::CreateDcdnDomainOfflineLogDeliveryRequest() :
RpcServiceRequest("dcdn", "2018-01-15", "CreateDcdnDomainOfflineLogDelivery")
{
setMethod(HttpRequest::Method::Post);
}
CreateDcdnDomainOfflineLogDeliveryRequest::~CreateDcdnDomainOfflineLogDeliveryRequest()
{}
std::string CreateDcdnDomainOfflineLogDeliveryRequest::getRegionId()const
{
return regionId_;
}
void CreateDcdnDomainOfflineLogDeliveryRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setBodyParameter("RegionId", regionId);
}
std::string CreateDcdnDomainOfflineLogDeliveryRequest::getDomainName()const
{
return domainName_;
}
void CreateDcdnDomainOfflineLogDeliveryRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setBodyParameter("DomainName", domainName);
}
long CreateDcdnDomainOfflineLogDeliveryRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDcdnDomainOfflineLogDeliveryRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDcdnDomainOfflineLogDeliveryRequest::getFieldId()const
{
return fieldId_;
}
void CreateDcdnDomainOfflineLogDeliveryRequest::setFieldId(const std::string& fieldId)
{
fieldId_ = fieldId;
setBodyParameter("FieldId", fieldId);
}

44
dcdn/src/model/CreateDcdnDomainOfflineLogDeliveryResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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 <alibabacloud/dcdn/model/CreateDcdnDomainOfflineLogDeliveryResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dcdn;
using namespace AlibabaCloud::Dcdn::Model;
CreateDcdnDomainOfflineLogDeliveryResult::CreateDcdnDomainOfflineLogDeliveryResult() :
ServiceResult()
{}
CreateDcdnDomainOfflineLogDeliveryResult::CreateDcdnDomainOfflineLogDeliveryResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDcdnDomainOfflineLogDeliveryResult::~CreateDcdnDomainOfflineLogDeliveryResult()
{}
void CreateDcdnDomainOfflineLogDeliveryResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

11
dcdn/src/model/DeleteDcdnDomainRequest.cc
View File

@@ -60,17 +60,6 @@ void DeleteDcdnDomainRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDcdnDomainRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void DeleteDcdnDomainRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string DeleteDcdnDomainRequest::getSecurityToken()const
{
return securityToken_;

33
dcdn/src/model/DeleteDcdnIpaDomainRequest.cc
View File

@@ -27,28 +27,6 @@ DeleteDcdnIpaDomainRequest::DeleteDcdnIpaDomainRequest() :
DeleteDcdnIpaDomainRequest::~DeleteDcdnIpaDomainRequest()
{}
std::string DeleteDcdnIpaDomainRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void DeleteDcdnIpaDomainRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string DeleteDcdnIpaDomainRequest::getSecurityToken()const
{
return securityToken_;
}
void DeleteDcdnIpaDomainRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string DeleteDcdnIpaDomainRequest::getOwnerAccount()const
{
return ownerAccount_;
@@ -82,3 +60,14 @@ void DeleteDcdnIpaDomainRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteDcdnIpaDomainRequest::getSecurityToken()const
{
return securityToken_;
}
void DeleteDcdnIpaDomainRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}

33
dcdn/src/model/DescribeDcdnDomainTopReferVisitRequest.cc
View File

@@ -27,17 +27,6 @@ DescribeDcdnDomainTopReferVisitRequest::DescribeDcdnDomainTopReferVisitRequest()
DescribeDcdnDomainTopReferVisitRequest::~DescribeDcdnDomainTopReferVisitRequest()
{}
std::string DescribeDcdnDomainTopReferVisitRequest::getDomainName()const
{
return domainName_;
}
void DescribeDcdnDomainTopReferVisitRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
std::string DescribeDcdnDomainTopReferVisitRequest::getStartTime()const
{
return startTime_;
@@ -49,6 +38,17 @@ void DescribeDcdnDomainTopReferVisitRequest::setStartTime(const std::string& sta
setParameter("StartTime", startTime);
}
std::string DescribeDcdnDomainTopReferVisitRequest::getDomainName()const
{
return domainName_;
}
void DescribeDcdnDomainTopReferVisitRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setParameter("DomainName", domainName);
}
long DescribeDcdnDomainTopReferVisitRequest::getOwnerId()const
{
return ownerId_;
@@ -60,17 +60,6 @@ void DescribeDcdnDomainTopReferVisitRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeDcdnDomainTopReferVisitRequest::getSecurityToken()const
{
return securityToken_;
}
void DescribeDcdnDomainTopReferVisitRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string DescribeDcdnDomainTopReferVisitRequest::getSortBy()const
{
return sortBy_;

40
dcdn/src/model/DescribeDcdnOfflineLogDeliveryFieldRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryFieldRequest.h>
using AlibabaCloud::Dcdn::Model::DescribeDcdnOfflineLogDeliveryFieldRequest;
DescribeDcdnOfflineLogDeliveryFieldRequest::DescribeDcdnOfflineLogDeliveryFieldRequest() :
RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnOfflineLogDeliveryField")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDcdnOfflineLogDeliveryFieldRequest::~DescribeDcdnOfflineLogDeliveryFieldRequest()
{}
long DescribeDcdnOfflineLogDeliveryFieldRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDcdnOfflineLogDeliveryFieldRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

61
dcdn/src/model/DescribeDcdnOfflineLogDeliveryFieldResult.cc Normal file
View File

@@ -0,0 +1,61 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryFieldResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dcdn;
using namespace AlibabaCloud::Dcdn::Model;
DescribeDcdnOfflineLogDeliveryFieldResult::DescribeDcdnOfflineLogDeliveryFieldResult() :
ServiceResult()
{}
DescribeDcdnOfflineLogDeliveryFieldResult::DescribeDcdnOfflineLogDeliveryFieldResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDcdnOfflineLogDeliveryFieldResult::~DescribeDcdnOfflineLogDeliveryFieldResult()
{}
void DescribeDcdnOfflineLogDeliveryFieldResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allFieldsNode = value["Fields"]["Field"];
for (auto valueFieldsField : allFieldsNode)
{
Field fieldsObject;
if(!valueFieldsField["FieldId"].isNull())
fieldsObject.fieldId = valueFieldsField["FieldId"].asString();
if(!valueFieldsField["FieldName"].isNull())
fieldsObject.fieldName = valueFieldsField["FieldName"].asString();
if(!valueFieldsField["Description"].isNull())
fieldsObject.description = valueFieldsField["Description"].asString();
fields_.push_back(fieldsObject);
}
}
std::vector<DescribeDcdnOfflineLogDeliveryFieldResult::Field> DescribeDcdnOfflineLogDeliveryFieldResult::getFields()const
{
return fields_;
}

40
dcdn/src/model/DescribeDcdnOfflineLogDeliveryRegionsRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryRegionsRequest.h>
using AlibabaCloud::Dcdn::Model::DescribeDcdnOfflineLogDeliveryRegionsRequest;
DescribeDcdnOfflineLogDeliveryRegionsRequest::DescribeDcdnOfflineLogDeliveryRegionsRequest() :
RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnOfflineLogDeliveryRegions")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDcdnOfflineLogDeliveryRegionsRequest::~DescribeDcdnOfflineLogDeliveryRegionsRequest()
{}
long DescribeDcdnOfflineLogDeliveryRegionsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDcdnOfflineLogDeliveryRegionsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

73
dcdn/src/model/DescribeDcdnOfflineLogDeliveryRegionsResult.cc Normal file
View File

@@ -0,0 +1,73 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryRegionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dcdn;
using namespace AlibabaCloud::Dcdn::Model;
DescribeDcdnOfflineLogDeliveryRegionsResult::DescribeDcdnOfflineLogDeliveryRegionsResult() :
ServiceResult()
{}
DescribeDcdnOfflineLogDeliveryRegionsResult::DescribeDcdnOfflineLogDeliveryRegionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDcdnOfflineLogDeliveryRegionsResult::~DescribeDcdnOfflineLogDeliveryRegionsResult()
{}
void DescribeDcdnOfflineLogDeliveryRegionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allAreasNode = value["Areas"]["Area"];
for (auto valueAreasArea : allAreasNode)
{
Area areasObject;
if(!valueAreasArea["AreaId"].isNull())
areasObject.areaId = valueAreasArea["AreaId"].asString();
if(!valueAreasArea["AreaName"].isNull())
areasObject.areaName = valueAreasArea["AreaName"].asString();
auto allRegionInfosNode = valueAreasArea["RegionInfos"]["RegionInfo"];
for (auto valueAreasAreaRegionInfosRegionInfo : allRegionInfosNode)
{
Area::RegionInfo regionInfosObject;
if(!valueAreasAreaRegionInfosRegionInfo["RegionId"].isNull())
regionInfosObject.regionId = valueAreasAreaRegionInfosRegionInfo["RegionId"].asString();
if(!valueAreasAreaRegionInfosRegionInfo["RegionName"].isNull())
regionInfosObject.regionName = valueAreasAreaRegionInfosRegionInfo["RegionName"].asString();
if(!valueAreasAreaRegionInfosRegionInfo["IsOverseas"].isNull())
regionInfosObject.isOverseas = valueAreasAreaRegionInfosRegionInfo["IsOverseas"].asString();
if(!valueAreasAreaRegionInfosRegionInfo["OssEndpoint"].isNull())
regionInfosObject.ossEndpoint = valueAreasAreaRegionInfosRegionInfo["OssEndpoint"].asString();
areasObject.regionInfos.push_back(regionInfosObject);
}
areas_.push_back(areasObject);
}
}
std::vector<DescribeDcdnOfflineLogDeliveryRegionsResult::Area> DescribeDcdnOfflineLogDeliveryRegionsResult::getAreas()const
{
return areas_;
}

40
dcdn/src/model/DescribeDcdnOfflineLogDeliveryRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryRequest.h>
using AlibabaCloud::Dcdn::Model::DescribeDcdnOfflineLogDeliveryRequest;
DescribeDcdnOfflineLogDeliveryRequest::DescribeDcdnOfflineLogDeliveryRequest() :
RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnOfflineLogDelivery")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDcdnOfflineLogDeliveryRequest::~DescribeDcdnOfflineLogDeliveryRequest()
{}
long DescribeDcdnOfflineLogDeliveryRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDcdnOfflineLogDeliveryRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

100
dcdn/src/model/DescribeDcdnOfflineLogDeliveryResult.cc Normal file
View File

@@ -0,0 +1,100 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dcdn;
using namespace AlibabaCloud::Dcdn::Model;
DescribeDcdnOfflineLogDeliveryResult::DescribeDcdnOfflineLogDeliveryResult() :
ServiceResult()
{}
DescribeDcdnOfflineLogDeliveryResult::DescribeDcdnOfflineLogDeliveryResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDcdnOfflineLogDeliveryResult::~DescribeDcdnOfflineLogDeliveryResult()
{}
void DescribeDcdnOfflineLogDeliveryResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDomainsNode = value["Domains"]["Domain"];
for (auto valueDomainsDomain : allDomainsNode)
{
Domain domainsObject;
if(!valueDomainsDomain["DomainName"].isNull())
domainsObject.domainName = valueDomainsDomain["DomainName"].asString();
domains_.push_back(domainsObject);
}
auto allRegionsNode = value["Regions"]["Region"];
for (auto valueRegionsRegion : allRegionsNode)
{
Region regionsObject;
if(!valueRegionsRegion["OssId"].isNull())
regionsObject.ossId = std::stoi(valueRegionsRegion["OssId"].asString());
if(!valueRegionsRegion["OssBucketName"].isNull())
regionsObject.ossBucketName = valueRegionsRegion["OssBucketName"].asString();
if(!valueRegionsRegion["OssPathPrefix"].isNull())
regionsObject.ossPathPrefix = valueRegionsRegion["OssPathPrefix"].asString();
if(!valueRegionsRegion["DlaVcName"].isNull())
regionsObject.dlaVcName = valueRegionsRegion["DlaVcName"].asString();
if(!valueRegionsRegion["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
if(!valueRegionsRegion["RegionName"].isNull())
regionsObject.regionName = valueRegionsRegion["RegionName"].asString();
if(!valueRegionsRegion["IsOverseas"].isNull())
regionsObject.isOverseas = valueRegionsRegion["IsOverseas"].asString();
if(!valueRegionsRegion["OssEndpoint"].isNull())
regionsObject.ossEndpoint = valueRegionsRegion["OssEndpoint"].asString();
if(!valueRegionsRegion["AreaId"].isNull())
regionsObject.areaId = valueRegionsRegion["AreaId"].asString();
if(!valueRegionsRegion["AreaName"].isNull())
regionsObject.areaName = valueRegionsRegion["AreaName"].asString();
if(!valueRegionsRegion["DlaDbName"].isNull())
regionsObject.dlaDbName = valueRegionsRegion["DlaDbName"].asString();
if(!valueRegionsRegion["DlaTableName"].isNull())
regionsObject.dlaTableName = valueRegionsRegion["DlaTableName"].asString();
regions_.push_back(regionsObject);
}
auto allFields = value["Fields"]["Field"];
for (const auto &item : allFields)
fields_.push_back(item.asString());
}
std::vector<DescribeDcdnOfflineLogDeliveryResult::Domain> DescribeDcdnOfflineLogDeliveryResult::getDomains()const
{
return domains_;
}
std::vector<std::string> DescribeDcdnOfflineLogDeliveryResult::getFields()const
{
return fields_;
}
std::vector<DescribeDcdnOfflineLogDeliveryResult::Region> DescribeDcdnOfflineLogDeliveryResult::getRegions()const
{
return regions_;
}

40
dcdn/src/model/DescribeDcdnOfflineLogDeliveryStatusRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryStatusRequest.h>
using AlibabaCloud::Dcdn::Model::DescribeDcdnOfflineLogDeliveryStatusRequest;
DescribeDcdnOfflineLogDeliveryStatusRequest::DescribeDcdnOfflineLogDeliveryStatusRequest() :
RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnOfflineLogDeliveryStatus")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDcdnOfflineLogDeliveryStatusRequest::~DescribeDcdnOfflineLogDeliveryStatusRequest()
{}
long DescribeDcdnOfflineLogDeliveryStatusRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDcdnOfflineLogDeliveryStatusRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

51
dcdn/src/model/DescribeDcdnOfflineLogDeliveryStatusResult.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnOfflineLogDeliveryStatusResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dcdn;
using namespace AlibabaCloud::Dcdn::Model;
DescribeDcdnOfflineLogDeliveryStatusResult::DescribeDcdnOfflineLogDeliveryStatusResult() :
ServiceResult()
{}
DescribeDcdnOfflineLogDeliveryStatusResult::DescribeDcdnOfflineLogDeliveryStatusResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDcdnOfflineLogDeliveryStatusResult::~DescribeDcdnOfflineLogDeliveryStatusResult()
{}
void DescribeDcdnOfflineLogDeliveryStatusResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["OpenStatus"].isNull())
openStatus_ = value["OpenStatus"].asString();
}
std::string DescribeDcdnOfflineLogDeliveryStatusResult::getOpenStatus()const
{
return openStatus_;
}

84
dcdn/src/model/DescribeDcdnUserDomainsByFuncRequest.cc Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnUserDomainsByFuncRequest.h>
using AlibabaCloud::Dcdn::Model::DescribeDcdnUserDomainsByFuncRequest;
DescribeDcdnUserDomainsByFuncRequest::DescribeDcdnUserDomainsByFuncRequest() :
RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnUserDomainsByFunc")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDcdnUserDomainsByFuncRequest::~DescribeDcdnUserDomainsByFuncRequest()
{}
int DescribeDcdnUserDomainsByFuncRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeDcdnUserDomainsByFuncRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeDcdnUserDomainsByFuncRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void DescribeDcdnUserDomainsByFuncRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
int DescribeDcdnUserDomainsByFuncRequest::getPageSize()const
{
return pageSize_;
}
void DescribeDcdnUserDomainsByFuncRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
long DescribeDcdnUserDomainsByFuncRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDcdnUserDomainsByFuncRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeDcdnUserDomainsByFuncRequest::getFuncId()const
{
return funcId_;
}
void DescribeDcdnUserDomainsByFuncRequest::setFuncId(int funcId)
{
funcId_ = funcId;
setParameter("FuncId", std::to_string(funcId));
}

112
dcdn/src/model/DescribeDcdnUserDomainsByFuncResult.cc Normal file
View File

@@ -0,0 +1,112 @@
/*
* 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 <alibabacloud/dcdn/model/DescribeDcdnUserDomainsByFuncResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dcdn;
using namespace AlibabaCloud::Dcdn::Model;
DescribeDcdnUserDomainsByFuncResult::DescribeDcdnUserDomainsByFuncResult() :
ServiceResult()
{}
DescribeDcdnUserDomainsByFuncResult::DescribeDcdnUserDomainsByFuncResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDcdnUserDomainsByFuncResult::~DescribeDcdnUserDomainsByFuncResult()
{}
void DescribeDcdnUserDomainsByFuncResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDomainsNode = value["Domains"]["PageData"];
for (auto valueDomainsPageData : allDomainsNode)
{
PageData domainsObject;
if(!valueDomainsPageData["DomainName"].isNull())
domainsObject.domainName = valueDomainsPageData["DomainName"].asString();
if(!valueDomainsPageData["Cname"].isNull())
domainsObject.cname = valueDomainsPageData["Cname"].asString();
if(!valueDomainsPageData["CdnType"].isNull())
domainsObject.cdnType = valueDomainsPageData["CdnType"].asString();
if(!valueDomainsPageData["DomainStatus"].isNull())
domainsObject.domainStatus = valueDomainsPageData["DomainStatus"].asString();
if(!valueDomainsPageData["GmtCreated"].isNull())
domainsObject.gmtCreated = valueDomainsPageData["GmtCreated"].asString();
if(!valueDomainsPageData["GmtModified"].isNull())
domainsObject.gmtModified = valueDomainsPageData["GmtModified"].asString();
if(!valueDomainsPageData["Description"].isNull())
domainsObject.description = valueDomainsPageData["Description"].asString();
if(!valueDomainsPageData["SslProtocol"].isNull())
domainsObject.sslProtocol = valueDomainsPageData["SslProtocol"].asString();
if(!valueDomainsPageData["ResourceGroupId"].isNull())
domainsObject.resourceGroupId = valueDomainsPageData["ResourceGroupId"].asString();
if(!valueDomainsPageData["Sandbox"].isNull())
domainsObject.sandbox = valueDomainsPageData["Sandbox"].asString();
auto allSourcesNode = valueDomainsPageData["Sources"]["Source"];
for (auto valueDomainsPageDataSourcesSource : allSourcesNode)
{
PageData::Source sourcesObject;
if(!valueDomainsPageDataSourcesSource["Type"].isNull())
sourcesObject.type = valueDomainsPageDataSourcesSource["Type"].asString();
if(!valueDomainsPageDataSourcesSource["Content"].isNull())
sourcesObject.content = valueDomainsPageDataSourcesSource["Content"].asString();
if(!valueDomainsPageDataSourcesSource["Port"].isNull())
sourcesObject.port = std::stoi(valueDomainsPageDataSourcesSource["Port"].asString());
if(!valueDomainsPageDataSourcesSource["Priority"].isNull())
sourcesObject.priority = valueDomainsPageDataSourcesSource["Priority"].asString();
if(!valueDomainsPageDataSourcesSource["Weight"].isNull())
sourcesObject.weight = valueDomainsPageDataSourcesSource["Weight"].asString();
domainsObject.sources.push_back(sourcesObject);
}
domains_.push_back(domainsObject);
}
if(!value["PageNumber"].isNull())
pageNumber_ = std::stol(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stol(value["PageSize"].asString());
if(!value["TotalCount"].isNull())
totalCount_ = std::stol(value["TotalCount"].asString());
}
std::vector<DescribeDcdnUserDomainsByFuncResult::PageData> DescribeDcdnUserDomainsByFuncResult::getDomains()const
{
return domains_;
}
long DescribeDcdnUserDomainsByFuncResult::getTotalCount()const
{
return totalCount_;
}
long DescribeDcdnUserDomainsByFuncResult::getPageSize()const
{
return pageSize_;
}
long DescribeDcdnUserDomainsByFuncResult::getPageNumber()const
{
return pageNumber_;
}

51
dcdn/src/model/DisableDcdnDomainOfflineLogDeliveryRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* 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 <alibabacloud/dcdn/model/DisableDcdnDomainOfflineLogDeliveryRequest.h>
using AlibabaCloud::Dcdn::Model::DisableDcdnDomainOfflineLogDeliveryRequest;
DisableDcdnDomainOfflineLogDeliveryRequest::DisableDcdnDomainOfflineLogDeliveryRequest() :
RpcServiceRequest("dcdn", "2018-01-15", "DisableDcdnDomainOfflineLogDelivery")
{
setMethod(HttpRequest::Method::Post);
}
DisableDcdnDomainOfflineLogDeliveryRequest::~DisableDcdnDomainOfflineLogDeliveryRequest()
{}
std::string DisableDcdnDomainOfflineLogDeliveryRequest::getDomainName()const
{
return domainName_;
}
void DisableDcdnDomainOfflineLogDeliveryRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setBodyParameter("DomainName", domainName);
}
long DisableDcdnDomainOfflineLogDeliveryRequest::getOwnerId()const
{
return ownerId_;
}
void DisableDcdnDomainOfflineLogDeliveryRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

44
dcdn/src/model/DisableDcdnDomainOfflineLogDeliveryResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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 <alibabacloud/dcdn/model/DisableDcdnDomainOfflineLogDeliveryResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dcdn;
using namespace AlibabaCloud::Dcdn::Model;
DisableDcdnDomainOfflineLogDeliveryResult::DisableDcdnDomainOfflineLogDeliveryResult() :
ServiceResult()
{}
DisableDcdnDomainOfflineLogDeliveryResult::DisableDcdnDomainOfflineLogDeliveryResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DisableDcdnDomainOfflineLogDeliveryResult::~DisableDcdnDomainOfflineLogDeliveryResult()
{}
void DisableDcdnDomainOfflineLogDeliveryResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

40
dcdn/src/model/DisableDcdnOfflineLogDeliveryRequest.cc Normal file
View File

@@ -0,0 +1,40 @@
/*
* 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 <alibabacloud/dcdn/model/DisableDcdnOfflineLogDeliveryRequest.h>
using AlibabaCloud::Dcdn::Model::DisableDcdnOfflineLogDeliveryRequest;
DisableDcdnOfflineLogDeliveryRequest::DisableDcdnOfflineLogDeliveryRequest() :
RpcServiceRequest("dcdn", "2018-01-15", "DisableDcdnOfflineLogDelivery")
{
setMethod(HttpRequest::Method::Post);
}
DisableDcdnOfflineLogDeliveryRequest::~DisableDcdnOfflineLogDeliveryRequest()
{}
long DisableDcdnOfflineLogDeliveryRequest::getOwnerId()const
{
return ownerId_;
}
void DisableDcdnOfflineLogDeliveryRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

44
dcdn/src/model/DisableDcdnOfflineLogDeliveryResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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 <alibabacloud/dcdn/model/DisableDcdnOfflineLogDeliveryResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dcdn;
using namespace AlibabaCloud::Dcdn::Model;
DisableDcdnOfflineLogDeliveryResult::DisableDcdnOfflineLogDeliveryResult() :
ServiceResult()
{}
DisableDcdnOfflineLogDeliveryResult::DisableDcdnOfflineLogDeliveryResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DisableDcdnOfflineLogDeliveryResult::~DisableDcdnOfflineLogDeliveryResult()
{}
void DisableDcdnOfflineLogDeliveryResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

51
dcdn/src/model/EnableDcdnDomainOfflineLogDeliveryRequest.cc Normal file
View File

@@ -0,0 +1,51 @@
/*
* 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 <alibabacloud/dcdn/model/EnableDcdnDomainOfflineLogDeliveryRequest.h>
using AlibabaCloud::Dcdn::Model::EnableDcdnDomainOfflineLogDeliveryRequest;
EnableDcdnDomainOfflineLogDeliveryRequest::EnableDcdnDomainOfflineLogDeliveryRequest() :
RpcServiceRequest("dcdn", "2018-01-15", "EnableDcdnDomainOfflineLogDelivery")
{
setMethod(HttpRequest::Method::Post);
}
EnableDcdnDomainOfflineLogDeliveryRequest::~EnableDcdnDomainOfflineLogDeliveryRequest()
{}
std::string EnableDcdnDomainOfflineLogDeliveryRequest::getDomainName()const
{
return domainName_;
}
void EnableDcdnDomainOfflineLogDeliveryRequest::setDomainName(const std::string& domainName)
{
domainName_ = domainName;
setBodyParameter("DomainName", domainName);
}
long EnableDcdnDomainOfflineLogDeliveryRequest::getOwnerId()const
{
return ownerId_;
}
void EnableDcdnDomainOfflineLogDeliveryRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

44
dcdn/src/model/EnableDcdnDomainOfflineLogDeliveryResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* 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 <alibabacloud/dcdn/model/EnableDcdnDomainOfflineLogDeliveryResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dcdn;
using namespace AlibabaCloud::Dcdn::Model;
EnableDcdnDomainOfflineLogDeliveryResult::EnableDcdnDomainOfflineLogDeliveryResult() :
ServiceResult()
{}
EnableDcdnDomainOfflineLogDeliveryResult::EnableDcdnDomainOfflineLogDeliveryResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
EnableDcdnDomainOfflineLogDeliveryResult::~EnableDcdnDomainOfflineLogDeliveryResult()
{}
void EnableDcdnDomainOfflineLogDeliveryResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}