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

Generate SDK by new Generator

Browse Source
This commit is contained in:
wb-hx510875
2019-09-18 11:18:56 +08:00
parent be86048a76
commit f3eaf1d292
9054 changed files with 325898 additions and 381375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

636
dbs/src/DbsClient.cc
View File

@@ -31,56 +31,56 @@ DbsClient::DbsClient(const Credentials &credentials, const ClientConfiguration &
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "cbs");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dbs");
}
DbsClient::DbsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "cbs");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dbs");
}
DbsClient::DbsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "cbs");
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dbs");
}
DbsClient::~DbsClient()
{}
DbsClient::DescribeBackupPlanListOutcome DbsClient::describeBackupPlanList(const DescribeBackupPlanListRequest &request) const
DbsClient::ConfigureBackupPlanOutcome DbsClient::configureBackupPlan(const ConfigureBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeBackupPlanListOutcome(endpointOutcome.error());
return ConfigureBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeBackupPlanListOutcome(DescribeBackupPlanListResult(outcome.result()));
return ConfigureBackupPlanOutcome(ConfigureBackupPlanResult(outcome.result()));
else
return DescribeBackupPlanListOutcome(outcome.error());
return ConfigureBackupPlanOutcome(outcome.error());
}
void DbsClient::describeBackupPlanListAsync(const DescribeBackupPlanListRequest& request, const DescribeBackupPlanListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::configureBackupPlanAsync(const ConfigureBackupPlanRequest& request, const ConfigureBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeBackupPlanList(request), context);
handler(this, request, configureBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeBackupPlanListOutcomeCallable DbsClient::describeBackupPlanListCallable(const DescribeBackupPlanListRequest &request) const
DbsClient::ConfigureBackupPlanOutcomeCallable DbsClient::configureBackupPlanCallable(const ConfigureBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeBackupPlanListOutcome()>>(
auto task = std::make_shared<std::packaged_task<ConfigureBackupPlanOutcome()>>(
[this, request]()
{
return this->describeBackupPlanList(request);
return this->configureBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -123,252 +123,36 @@ DbsClient::CreateBackupPlanOutcomeCallable DbsClient::createBackupPlanCallable(c
return task->get_future();
}
DbsClient::StartBackupPlanOutcome DbsClient::startBackupPlan(const StartBackupPlanRequest &request) const
DbsClient::CreateRestoreTaskOutcome DbsClient::createRestoreTask(const CreateRestoreTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartBackupPlanOutcome(endpointOutcome.error());
return CreateRestoreTaskOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartBackupPlanOutcome(StartBackupPlanResult(outcome.result()));
return CreateRestoreTaskOutcome(CreateRestoreTaskResult(outcome.result()));
else
return StartBackupPlanOutcome(outcome.error());
return CreateRestoreTaskOutcome(outcome.error());
}
void DbsClient::startBackupPlanAsync(const StartBackupPlanRequest& request, const StartBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::createRestoreTaskAsync(const CreateRestoreTaskRequest& request, const CreateRestoreTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startBackupPlan(request), context);
handler(this, request, createRestoreTask(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::StartBackupPlanOutcomeCallable DbsClient::startBackupPlanCallable(const StartBackupPlanRequest &request) const
DbsClient::CreateRestoreTaskOutcomeCallable DbsClient::createRestoreTaskCallable(const CreateRestoreTaskRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartBackupPlanOutcome()>>(
auto task = std::make_shared<std::packaged_task<CreateRestoreTaskOutcome()>>(
[this, request]()
{
return this->startBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::RenewBackupPlanOutcome DbsClient::renewBackupPlan(const RenewBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RenewBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RenewBackupPlanOutcome(RenewBackupPlanResult(outcome.result()));
else
return RenewBackupPlanOutcome(outcome.error());
}
void DbsClient::renewBackupPlanAsync(const RenewBackupPlanRequest& request, const RenewBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, renewBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::RenewBackupPlanOutcomeCallable DbsClient::renewBackupPlanCallable(const RenewBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RenewBackupPlanOutcome()>>(
[this, request]()
{
return this->renewBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::DescribeFullBackupListOutcome DbsClient::describeFullBackupList(const DescribeFullBackupListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeFullBackupListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeFullBackupListOutcome(DescribeFullBackupListResult(outcome.result()));
else
return DescribeFullBackupListOutcome(outcome.error());
}
void DbsClient::describeFullBackupListAsync(const DescribeFullBackupListRequest& request, const DescribeFullBackupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeFullBackupList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeFullBackupListOutcomeCallable DbsClient::describeFullBackupListCallable(const DescribeFullBackupListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeFullBackupListOutcome()>>(
[this, request]()
{
return this->describeFullBackupList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::UpgradeBackupPlanOutcome DbsClient::upgradeBackupPlan(const UpgradeBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpgradeBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpgradeBackupPlanOutcome(UpgradeBackupPlanResult(outcome.result()));
else
return UpgradeBackupPlanOutcome(outcome.error());
}
void DbsClient::upgradeBackupPlanAsync(const UpgradeBackupPlanRequest& request, const UpgradeBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, upgradeBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::UpgradeBackupPlanOutcomeCallable DbsClient::upgradeBackupPlanCallable(const UpgradeBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpgradeBackupPlanOutcome()>>(
[this, request]()
{
return this->upgradeBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::DescribeRestoreTaskListOutcome DbsClient::describeRestoreTaskList(const DescribeRestoreTaskListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeRestoreTaskListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeRestoreTaskListOutcome(DescribeRestoreTaskListResult(outcome.result()));
else
return DescribeRestoreTaskListOutcome(outcome.error());
}
void DbsClient::describeRestoreTaskListAsync(const DescribeRestoreTaskListRequest& request, const DescribeRestoreTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeRestoreTaskList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeRestoreTaskListOutcomeCallable DbsClient::describeRestoreTaskListCallable(const DescribeRestoreTaskListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeRestoreTaskListOutcome()>>(
[this, request]()
{
return this->describeRestoreTaskList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupPlanNameOutcome DbsClient::modifyBackupPlanName(const ModifyBackupPlanNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupPlanNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupPlanNameOutcome(ModifyBackupPlanNameResult(outcome.result()));
else
return ModifyBackupPlanNameOutcome(outcome.error());
}
void DbsClient::modifyBackupPlanNameAsync(const ModifyBackupPlanNameRequest& request, const ModifyBackupPlanNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupPlanName(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupPlanNameOutcomeCallable DbsClient::modifyBackupPlanNameCallable(const ModifyBackupPlanNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupPlanNameOutcome()>>(
[this, request]()
{
return this->modifyBackupPlanName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::StopBackupPlanOutcome DbsClient::stopBackupPlan(const StopBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StopBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StopBackupPlanOutcome(StopBackupPlanResult(outcome.result()));
else
return StopBackupPlanOutcome(outcome.error());
}
void DbsClient::stopBackupPlanAsync(const StopBackupPlanRequest& request, const StopBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, stopBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::StopBackupPlanOutcomeCallable DbsClient::stopBackupPlanCallable(const StopBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StopBackupPlanOutcome()>>(
[this, request]()
{
return this->stopBackupPlan(request);
return this->createRestoreTask(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -411,108 +195,72 @@ DbsClient::DescribeBackupGatewayListOutcomeCallable DbsClient::describeBackupGat
return task->get_future();
}
DbsClient::ModifyBackupSourceEndpointOutcome DbsClient::modifyBackupSourceEndpoint(const ModifyBackupSourceEndpointRequest &request) const
DbsClient::DescribeBackupPlanListOutcome DbsClient::describeBackupPlanList(const DescribeBackupPlanListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupSourceEndpointOutcome(endpointOutcome.error());
return DescribeBackupPlanListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupSourceEndpointOutcome(ModifyBackupSourceEndpointResult(outcome.result()));
return DescribeBackupPlanListOutcome(DescribeBackupPlanListResult(outcome.result()));
else
return ModifyBackupSourceEndpointOutcome(outcome.error());
return DescribeBackupPlanListOutcome(outcome.error());
}
void DbsClient::modifyBackupSourceEndpointAsync(const ModifyBackupSourceEndpointRequest& request, const ModifyBackupSourceEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::describeBackupPlanListAsync(const DescribeBackupPlanListRequest& request, const DescribeBackupPlanListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupSourceEndpoint(request), context);
handler(this, request, describeBackupPlanList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupSourceEndpointOutcomeCallable DbsClient::modifyBackupSourceEndpointCallable(const ModifyBackupSourceEndpointRequest &request) const
DbsClient::DescribeBackupPlanListOutcomeCallable DbsClient::describeBackupPlanListCallable(const DescribeBackupPlanListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupSourceEndpointOutcome()>>(
auto task = std::make_shared<std::packaged_task<DescribeBackupPlanListOutcome()>>(
[this, request]()
{
return this->modifyBackupSourceEndpoint(request);
return this->describeBackupPlanList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::DescribePreCheckProgressListOutcome DbsClient::describePreCheckProgressList(const DescribePreCheckProgressListRequest &request) const
DbsClient::DescribeFullBackupListOutcome DbsClient::describeFullBackupList(const DescribeFullBackupListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribePreCheckProgressListOutcome(endpointOutcome.error());
return DescribeFullBackupListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribePreCheckProgressListOutcome(DescribePreCheckProgressListResult(outcome.result()));
return DescribeFullBackupListOutcome(DescribeFullBackupListResult(outcome.result()));
else
return DescribePreCheckProgressListOutcome(outcome.error());
return DescribeFullBackupListOutcome(outcome.error());
}
void DbsClient::describePreCheckProgressListAsync(const DescribePreCheckProgressListRequest& request, const DescribePreCheckProgressListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::describeFullBackupListAsync(const DescribeFullBackupListRequest& request, const DescribeFullBackupListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describePreCheckProgressList(request), context);
handler(this, request, describeFullBackupList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribePreCheckProgressListOutcomeCallable DbsClient::describePreCheckProgressListCallable(const DescribePreCheckProgressListRequest &request) const
DbsClient::DescribeFullBackupListOutcomeCallable DbsClient::describeFullBackupListCallable(const DescribeFullBackupListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribePreCheckProgressListOutcome()>>(
auto task = std::make_shared<std::packaged_task<DescribeFullBackupListOutcome()>>(
[this, request]()
{
return this->describePreCheckProgressList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupObjectsOutcome DbsClient::modifyBackupObjects(const ModifyBackupObjectsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupObjectsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupObjectsOutcome(ModifyBackupObjectsResult(outcome.result()));
else
return ModifyBackupObjectsOutcome(outcome.error());
}
void DbsClient::modifyBackupObjectsAsync(const ModifyBackupObjectsRequest& request, const ModifyBackupObjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupObjects(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupObjectsOutcomeCallable DbsClient::modifyBackupObjectsCallable(const ModifyBackupObjectsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupObjectsOutcome()>>(
[this, request]()
{
return this->modifyBackupObjects(request);
return this->describeFullBackupList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -555,72 +303,216 @@ DbsClient::DescribeIncrementBackupListOutcomeCallable DbsClient::describeIncreme
return task->get_future();
}
DbsClient::CreateRestoreTaskOutcome DbsClient::createRestoreTask(const CreateRestoreTaskRequest &request) const
DbsClient::DescribeNodeCidrListOutcome DbsClient::describeNodeCidrList(const DescribeNodeCidrListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateRestoreTaskOutcome(endpointOutcome.error());
return DescribeNodeCidrListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateRestoreTaskOutcome(CreateRestoreTaskResult(outcome.result()));
return DescribeNodeCidrListOutcome(DescribeNodeCidrListResult(outcome.result()));
else
return CreateRestoreTaskOutcome(outcome.error());
return DescribeNodeCidrListOutcome(outcome.error());
}
void DbsClient::createRestoreTaskAsync(const CreateRestoreTaskRequest& request, const CreateRestoreTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::describeNodeCidrListAsync(const DescribeNodeCidrListRequest& request, const DescribeNodeCidrListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createRestoreTask(request), context);
handler(this, request, describeNodeCidrList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::CreateRestoreTaskOutcomeCallable DbsClient::createRestoreTaskCallable(const CreateRestoreTaskRequest &request) const
DbsClient::DescribeNodeCidrListOutcomeCallable DbsClient::describeNodeCidrListCallable(const DescribeNodeCidrListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateRestoreTaskOutcome()>>(
auto task = std::make_shared<std::packaged_task<DescribeNodeCidrListOutcome()>>(
[this, request]()
{
return this->createRestoreTask(request);
return this->describeNodeCidrList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ConfigureBackupPlanOutcome DbsClient::configureBackupPlan(const ConfigureBackupPlanRequest &request) const
DbsClient::DescribePreCheckProgressListOutcome DbsClient::describePreCheckProgressList(const DescribePreCheckProgressListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ConfigureBackupPlanOutcome(endpointOutcome.error());
return DescribePreCheckProgressListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ConfigureBackupPlanOutcome(ConfigureBackupPlanResult(outcome.result()));
return DescribePreCheckProgressListOutcome(DescribePreCheckProgressListResult(outcome.result()));
else
return ConfigureBackupPlanOutcome(outcome.error());
return DescribePreCheckProgressListOutcome(outcome.error());
}
void DbsClient::configureBackupPlanAsync(const ConfigureBackupPlanRequest& request, const ConfigureBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::describePreCheckProgressListAsync(const DescribePreCheckProgressListRequest& request, const DescribePreCheckProgressListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, configureBackupPlan(request), context);
handler(this, request, describePreCheckProgressList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ConfigureBackupPlanOutcomeCallable DbsClient::configureBackupPlanCallable(const ConfigureBackupPlanRequest &request) const
DbsClient::DescribePreCheckProgressListOutcomeCallable DbsClient::describePreCheckProgressListCallable(const DescribePreCheckProgressListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ConfigureBackupPlanOutcome()>>(
auto task = std::make_shared<std::packaged_task<DescribePreCheckProgressListOutcome()>>(
[this, request]()
{
return this->configureBackupPlan(request);
return this->describePreCheckProgressList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::DescribeRestoreTaskListOutcome DbsClient::describeRestoreTaskList(const DescribeRestoreTaskListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeRestoreTaskListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeRestoreTaskListOutcome(DescribeRestoreTaskListResult(outcome.result()));
else
return DescribeRestoreTaskListOutcome(outcome.error());
}
void DbsClient::describeRestoreTaskListAsync(const DescribeRestoreTaskListRequest& request, const DescribeRestoreTaskListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeRestoreTaskList(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeRestoreTaskListOutcomeCallable DbsClient::describeRestoreTaskListCallable(const DescribeRestoreTaskListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeRestoreTaskListOutcome()>>(
[this, request]()
{
return this->describeRestoreTaskList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupObjectsOutcome DbsClient::modifyBackupObjects(const ModifyBackupObjectsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupObjectsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupObjectsOutcome(ModifyBackupObjectsResult(outcome.result()));
else
return ModifyBackupObjectsOutcome(outcome.error());
}
void DbsClient::modifyBackupObjectsAsync(const ModifyBackupObjectsRequest& request, const ModifyBackupObjectsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupObjects(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupObjectsOutcomeCallable DbsClient::modifyBackupObjectsCallable(const ModifyBackupObjectsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupObjectsOutcome()>>(
[this, request]()
{
return this->modifyBackupObjects(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupPlanNameOutcome DbsClient::modifyBackupPlanName(const ModifyBackupPlanNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupPlanNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupPlanNameOutcome(ModifyBackupPlanNameResult(outcome.result()));
else
return ModifyBackupPlanNameOutcome(outcome.error());
}
void DbsClient::modifyBackupPlanNameAsync(const ModifyBackupPlanNameRequest& request, const ModifyBackupPlanNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupPlanName(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupPlanNameOutcomeCallable DbsClient::modifyBackupPlanNameCallable(const ModifyBackupPlanNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupPlanNameOutcome()>>(
[this, request]()
{
return this->modifyBackupPlanName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::ModifyBackupSourceEndpointOutcome DbsClient::modifyBackupSourceEndpoint(const ModifyBackupSourceEndpointRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyBackupSourceEndpointOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyBackupSourceEndpointOutcome(ModifyBackupSourceEndpointResult(outcome.result()));
else
return ModifyBackupSourceEndpointOutcome(outcome.error());
}
void DbsClient::modifyBackupSourceEndpointAsync(const ModifyBackupSourceEndpointRequest& request, const ModifyBackupSourceEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyBackupSourceEndpoint(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::ModifyBackupSourceEndpointOutcomeCallable DbsClient::modifyBackupSourceEndpointCallable(const ModifyBackupSourceEndpointRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyBackupSourceEndpointOutcome()>>(
[this, request]()
{
return this->modifyBackupSourceEndpoint(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -663,6 +555,78 @@ DbsClient::ModifyBackupStrategyOutcomeCallable DbsClient::modifyBackupStrategyCa
return task->get_future();
}
DbsClient::RenewBackupPlanOutcome DbsClient::renewBackupPlan(const RenewBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RenewBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RenewBackupPlanOutcome(RenewBackupPlanResult(outcome.result()));
else
return RenewBackupPlanOutcome(outcome.error());
}
void DbsClient::renewBackupPlanAsync(const RenewBackupPlanRequest& request, const RenewBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, renewBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::RenewBackupPlanOutcomeCallable DbsClient::renewBackupPlanCallable(const RenewBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RenewBackupPlanOutcome()>>(
[this, request]()
{
return this->renewBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::StartBackupPlanOutcome DbsClient::startBackupPlan(const StartBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartBackupPlanOutcome(StartBackupPlanResult(outcome.result()));
else
return StartBackupPlanOutcome(outcome.error());
}
void DbsClient::startBackupPlanAsync(const StartBackupPlanRequest& request, const StartBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::StartBackupPlanOutcomeCallable DbsClient::startBackupPlanCallable(const StartBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartBackupPlanOutcome()>>(
[this, request]()
{
return this->startBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::StartRestoreTaskOutcome DbsClient::startRestoreTask(const StartRestoreTaskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -699,36 +663,72 @@ DbsClient::StartRestoreTaskOutcomeCallable DbsClient::startRestoreTaskCallable(c
return task->get_future();
}
DbsClient::DescribeNodeCidrListOutcome DbsClient::describeNodeCidrList(const DescribeNodeCidrListRequest &request) const
DbsClient::StopBackupPlanOutcome DbsClient::stopBackupPlan(const StopBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeNodeCidrListOutcome(endpointOutcome.error());
return StopBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeNodeCidrListOutcome(DescribeNodeCidrListResult(outcome.result()));
return StopBackupPlanOutcome(StopBackupPlanResult(outcome.result()));
else
return DescribeNodeCidrListOutcome(outcome.error());
return StopBackupPlanOutcome(outcome.error());
}
void DbsClient::describeNodeCidrListAsync(const DescribeNodeCidrListRequest& request, const DescribeNodeCidrListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
void DbsClient::stopBackupPlanAsync(const StopBackupPlanRequest& request, const StopBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeNodeCidrList(request), context);
handler(this, request, stopBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::DescribeNodeCidrListOutcomeCallable DbsClient::describeNodeCidrListCallable(const DescribeNodeCidrListRequest &request) const
DbsClient::StopBackupPlanOutcomeCallable DbsClient::stopBackupPlanCallable(const StopBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeNodeCidrListOutcome()>>(
auto task = std::make_shared<std::packaged_task<StopBackupPlanOutcome()>>(
[this, request]()
{
return this->describeNodeCidrList(request);
return this->stopBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
DbsClient::UpgradeBackupPlanOutcome DbsClient::upgradeBackupPlan(const UpgradeBackupPlanRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return UpgradeBackupPlanOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return UpgradeBackupPlanOutcome(UpgradeBackupPlanResult(outcome.result()));
else
return UpgradeBackupPlanOutcome(outcome.error());
}
void DbsClient::upgradeBackupPlanAsync(const UpgradeBackupPlanRequest& request, const UpgradeBackupPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, upgradeBackupPlan(request), context);
};
asyncExecute(new Runnable(fn));
}
DbsClient::UpgradeBackupPlanOutcomeCallable DbsClient::upgradeBackupPlanCallable(const UpgradeBackupPlanRequest &request) const
{
auto task = std::make_shared<std::packaged_task<UpgradeBackupPlanOutcome()>>(
[this, request]()
{
return this->upgradeBackupPlan(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));

165
dbs/src/model/ConfigureBackupPlanRequest.cc
View File

@@ -36,17 +36,6 @@ void ConfigureBackupPlanRequest::setSourceEndpointRegion(const std::string& sour
setCoreParameter("SourceEndpointRegion", sourceEndpointRegion);
}
int ConfigureBackupPlanRequest::getDuplicationArchivePeriod()const
{
return duplicationArchivePeriod_;
}
void ConfigureBackupPlanRequest::setDuplicationArchivePeriod(int duplicationArchivePeriod)
{
duplicationArchivePeriod_ = duplicationArchivePeriod;
setCoreParameter("DuplicationArchivePeriod", std::to_string(duplicationArchivePeriod));
}
long ConfigureBackupPlanRequest::getBackupGatewayId()const
{
return backupGatewayId_;
@@ -91,17 +80,6 @@ void ConfigureBackupPlanRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointPassword()const
{
return sourceEndpointPassword_;
}
void ConfigureBackupPlanRequest::setSourceEndpointPassword(const std::string& sourceEndpointPassword)
{
sourceEndpointPassword_ = sourceEndpointPassword;
setCoreParameter("SourceEndpointPassword", sourceEndpointPassword);
}
std::string ConfigureBackupPlanRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -113,6 +91,83 @@ void ConfigureBackupPlanRequest::setBackupPlanId(const std::string& backupPlanId
setCoreParameter("BackupPlanId", backupPlanId);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointDatabaseName()const
{
return sourceEndpointDatabaseName_;
}
void ConfigureBackupPlanRequest::setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName)
{
sourceEndpointDatabaseName_ = sourceEndpointDatabaseName;
setCoreParameter("SourceEndpointDatabaseName", sourceEndpointDatabaseName);
}
int ConfigureBackupPlanRequest::getDuplicationInfrequentAccessPeriod()const
{
return duplicationInfrequentAccessPeriod_;
}
void ConfigureBackupPlanRequest::setDuplicationInfrequentAccessPeriod(int duplicationInfrequentAccessPeriod)
{
duplicationInfrequentAccessPeriod_ = duplicationInfrequentAccessPeriod;
setCoreParameter("DuplicationInfrequentAccessPeriod", std::to_string(duplicationInfrequentAccessPeriod));
}
std::string ConfigureBackupPlanRequest::getBackupStartTime()const
{
return backupStartTime_;
}
void ConfigureBackupPlanRequest::setBackupStartTime(const std::string& backupStartTime)
{
backupStartTime_ = backupStartTime;
setCoreParameter("BackupStartTime", backupStartTime);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointIP()const
{
return sourceEndpointIP_;
}
void ConfigureBackupPlanRequest::setSourceEndpointIP(const std::string& sourceEndpointIP)
{
sourceEndpointIP_ = sourceEndpointIP;
setCoreParameter("SourceEndpointIP", sourceEndpointIP);
}
bool ConfigureBackupPlanRequest::getEnableBackupLog()const
{
return enableBackupLog_;
}
void ConfigureBackupPlanRequest::setEnableBackupLog(bool enableBackupLog)
{
enableBackupLog_ = enableBackupLog;
setCoreParameter("EnableBackupLog", enableBackupLog ? "true" : "false");
}
int ConfigureBackupPlanRequest::getDuplicationArchivePeriod()const
{
return duplicationArchivePeriod_;
}
void ConfigureBackupPlanRequest::setDuplicationArchivePeriod(int duplicationArchivePeriod)
{
duplicationArchivePeriod_ = duplicationArchivePeriod;
setCoreParameter("DuplicationArchivePeriod", std::to_string(duplicationArchivePeriod));
}
std::string ConfigureBackupPlanRequest::getSourceEndpointPassword()const
{
return sourceEndpointPassword_;
}
void ConfigureBackupPlanRequest::setSourceEndpointPassword(const std::string& sourceEndpointPassword)
{
sourceEndpointPassword_ = sourceEndpointPassword;
setCoreParameter("SourceEndpointPassword", sourceEndpointPassword);
}
std::string ConfigureBackupPlanRequest::getBackupObjects()const
{
return backupObjects_;
@@ -146,17 +201,6 @@ void ConfigureBackupPlanRequest::setSourceEndpointPort(int sourceEndpointPort)
setCoreParameter("SourceEndpointPort", std::to_string(sourceEndpointPort));
}
std::string ConfigureBackupPlanRequest::getSourceEndpointDatabaseName()const
{
return sourceEndpointDatabaseName_;
}
void ConfigureBackupPlanRequest::setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName)
{
sourceEndpointDatabaseName_ = sourceEndpointDatabaseName;
setCoreParameter("SourceEndpointDatabaseName", sourceEndpointDatabaseName);
}
int ConfigureBackupPlanRequest::getBackupRetentionPeriod()const
{
return backupRetentionPeriod_;
@@ -168,17 +212,6 @@ void ConfigureBackupPlanRequest::setBackupRetentionPeriod(int backupRetentionPer
setCoreParameter("BackupRetentionPeriod", std::to_string(backupRetentionPeriod));
}
int ConfigureBackupPlanRequest::getDuplicationInfrequentAccessPeriod()const
{
return duplicationInfrequentAccessPeriod_;
}
void ConfigureBackupPlanRequest::setDuplicationInfrequentAccessPeriod(int duplicationInfrequentAccessPeriod)
{
duplicationInfrequentAccessPeriod_ = duplicationInfrequentAccessPeriod;
setCoreParameter("DuplicationInfrequentAccessPeriod", std::to_string(duplicationInfrequentAccessPeriod));
}
std::string ConfigureBackupPlanRequest::getBackupPeriod()const
{
return backupPeriod_;
@@ -190,17 +223,6 @@ void ConfigureBackupPlanRequest::setBackupPeriod(const std::string& backupPeriod
setCoreParameter("BackupPeriod", backupPeriod);
}
std::string ConfigureBackupPlanRequest::getBackupStartTime()const
{
return backupStartTime_;
}
void ConfigureBackupPlanRequest::setBackupStartTime(const std::string& backupStartTime)
{
backupStartTime_ = backupStartTime;
setCoreParameter("BackupStartTime", backupStartTime);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointInstanceType()const
{
return sourceEndpointInstanceType_;
@@ -212,17 +234,6 @@ void ConfigureBackupPlanRequest::setSourceEndpointInstanceType(const std::string
setCoreParameter("SourceEndpointInstanceType", sourceEndpointInstanceType);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointIP()const
{
return sourceEndpointIP_;
}
void ConfigureBackupPlanRequest::setSourceEndpointIP(const std::string& sourceEndpointIP)
{
sourceEndpointIP_ = sourceEndpointIP;
setCoreParameter("SourceEndpointIP", sourceEndpointIP);
}
std::string ConfigureBackupPlanRequest::getBackupPlanName()const
{
return backupPlanName_;
@@ -234,17 +245,6 @@ void ConfigureBackupPlanRequest::setBackupPlanName(const std::string& backupPlan
setCoreParameter("BackupPlanName", backupPlanName);
}
std::string ConfigureBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void ConfigureBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ConfigureBackupPlanRequest::getSourceEndpointOracleSID()const
{
return sourceEndpointOracleSID_;
@@ -267,14 +267,3 @@ void ConfigureBackupPlanRequest::setOSSBucketName(const std::string& oSSBucketNa
setCoreParameter("OSSBucketName", oSSBucketName);
}
bool ConfigureBackupPlanRequest::getEnableBackupLog()const
{
return enableBackupLog_;
}
void ConfigureBackupPlanRequest::setEnableBackupLog(bool enableBackupLog)
{
enableBackupLog_ = enableBackupLog;
setCoreParameter("EnableBackupLog", enableBackupLog ? "true" : "false");
}

8
dbs/src/model/ConfigureBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ ConfigureBackupPlanResult::~ConfigureBackupPlanResult()
void ConfigureBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

121
dbs/src/model/CreateBackupPlanRequest.cc
View File

@@ -36,17 +36,6 @@ void CreateBackupPlanRequest::setDatabaseType(const std::string& databaseType)
setCoreParameter("DatabaseType", databaseType);
}
std::string CreateBackupPlanRequest::getPeriod()const
{
return period_;
}
void CreateBackupPlanRequest::setPeriod(const std::string& period)
{
period_ = period;
setCoreParameter("Period", period);
}
std::string CreateBackupPlanRequest::getClientToken()const
{
return clientToken_;
@@ -58,28 +47,6 @@ void CreateBackupPlanRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string CreateBackupPlanRequest::getOwnerId()const
{
return ownerId_;
}
void CreateBackupPlanRequest::setOwnerId(const std::string& ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", ownerId);
}
int CreateBackupPlanRequest::getUsedTime()const
{
return usedTime_;
}
void CreateBackupPlanRequest::setUsedTime(int usedTime)
{
usedTime_ = usedTime;
setCoreParameter("UsedTime", std::to_string(usedTime));
}
std::string CreateBackupPlanRequest::getInstanceClass()const
{
return instanceClass_;
@@ -102,17 +69,6 @@ void CreateBackupPlanRequest::setStorageType(const std::string& storageType)
setCoreParameter("StorageType", storageType);
}
std::string CreateBackupPlanRequest::getBackupMethod()const
{
return backupMethod_;
}
void CreateBackupPlanRequest::setBackupMethod(const std::string& backupMethod)
{
backupMethod_ = backupMethod;
setCoreParameter("BackupMethod", backupMethod);
}
std::string CreateBackupPlanRequest::getDatabaseRegion()const
{
return databaseRegion_;
@@ -124,28 +80,6 @@ void CreateBackupPlanRequest::setDatabaseRegion(const std::string& databaseRegio
setCoreParameter("DatabaseRegion", databaseRegion);
}
std::string CreateBackupPlanRequest::getStorageRegion()const
{
return storageRegion_;
}
void CreateBackupPlanRequest::setStorageRegion(const std::string& storageRegion)
{
storageRegion_ = storageRegion;
setCoreParameter("StorageRegion", storageRegion);
}
std::string CreateBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void CreateBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateBackupPlanRequest::getInstanceType()const
{
return instanceType_;
@@ -157,6 +91,61 @@ void CreateBackupPlanRequest::setInstanceType(const std::string& instanceType)
setCoreParameter("InstanceType", instanceType);
}
std::string CreateBackupPlanRequest::getPeriod()const
{
return period_;
}
void CreateBackupPlanRequest::setPeriod(const std::string& period)
{
period_ = period;
setCoreParameter("Period", period);
}
std::string CreateBackupPlanRequest::getOwnerId()const
{
return ownerId_;
}
void CreateBackupPlanRequest::setOwnerId(const std::string& ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", ownerId);
}
int CreateBackupPlanRequest::getUsedTime()const
{
return usedTime_;
}
void CreateBackupPlanRequest::setUsedTime(int usedTime)
{
usedTime_ = usedTime;
setCoreParameter("UsedTime", std::to_string(usedTime));
}
std::string CreateBackupPlanRequest::getBackupMethod()const
{
return backupMethod_;
}
void CreateBackupPlanRequest::setBackupMethod(const std::string& backupMethod)
{
backupMethod_ = backupMethod;
setCoreParameter("BackupMethod", backupMethod);
}
std::string CreateBackupPlanRequest::getStorageRegion()const
{
return storageRegion_;
}
void CreateBackupPlanRequest::setStorageRegion(const std::string& storageRegion)
{
storageRegion_ = storageRegion;
setCoreParameter("StorageRegion", storageRegion);
}
std::string CreateBackupPlanRequest::getRegion()const
{
return region_;

8
dbs/src/model/CreateBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ CreateBackupPlanResult::~CreateBackupPlanResult()
void CreateBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

209
dbs/src/model/CreateRestoreTaskRequest.cc
View File

@@ -36,28 +36,6 @@ void CreateRestoreTaskRequest::setBackupGatewayId(long backupGatewayId)
setCoreParameter("BackupGatewayId", std::to_string(backupGatewayId));
}
std::string CreateRestoreTaskRequest::getDestinationEndpointOracleSID()const
{
return destinationEndpointOracleSID_;
}
void CreateRestoreTaskRequest::setDestinationEndpointOracleSID(const std::string& destinationEndpointOracleSID)
{
destinationEndpointOracleSID_ = destinationEndpointOracleSID;
setCoreParameter("DestinationEndpointOracleSID", destinationEndpointOracleSID);
}
long CreateRestoreTaskRequest::getRestoreTime()const
{
return restoreTime_;
}
void CreateRestoreTaskRequest::setRestoreTime(long restoreTime)
{
restoreTime_ = restoreTime;
setCoreParameter("RestoreTime", std::to_string(restoreTime));
}
std::string CreateRestoreTaskRequest::getDestinationEndpointInstanceType()const
{
return destinationEndpointInstanceType_;
@@ -80,28 +58,6 @@ void CreateRestoreTaskRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointInstanceID()const
{
return destinationEndpointInstanceID_;
}
void CreateRestoreTaskRequest::setDestinationEndpointInstanceID(const std::string& destinationEndpointInstanceID)
{
destinationEndpointInstanceID_ = destinationEndpointInstanceID;
setCoreParameter("DestinationEndpointInstanceID", destinationEndpointInstanceID);
}
int CreateRestoreTaskRequest::getDestinationEndpointPort()const
{
return destinationEndpointPort_;
}
void CreateRestoreTaskRequest::setDestinationEndpointPort(int destinationEndpointPort)
{
destinationEndpointPort_ = destinationEndpointPort;
setCoreParameter("DestinationEndpointPort", std::to_string(destinationEndpointPort));
}
std::string CreateRestoreTaskRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -113,28 +69,6 @@ void CreateRestoreTaskRequest::setBackupPlanId(const std::string& backupPlanId)
setCoreParameter("BackupPlanId", backupPlanId);
}
std::string CreateRestoreTaskRequest::getBackupSetId()const
{
return backupSetId_;
}
void CreateRestoreTaskRequest::setBackupSetId(const std::string& backupSetId)
{
backupSetId_ = backupSetId;
setCoreParameter("BackupSetId", backupSetId);
}
std::string CreateRestoreTaskRequest::getOwnerId()const
{
return ownerId_;
}
void CreateRestoreTaskRequest::setOwnerId(const std::string& ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", ownerId);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointRegion()const
{
return destinationEndpointRegion_;
@@ -146,50 +80,6 @@ void CreateRestoreTaskRequest::setDestinationEndpointRegion(const std::string& d
setCoreParameter("DestinationEndpointRegion", destinationEndpointRegion);
}
std::string CreateRestoreTaskRequest::getRestoreDir()const
{
return restoreDir_;
}
void CreateRestoreTaskRequest::setRestoreDir(const std::string& restoreDir)
{
restoreDir_ = restoreDir;
setCoreParameter("RestoreDir", restoreDir);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointIP()const
{
return destinationEndpointIP_;
}
void CreateRestoreTaskRequest::setDestinationEndpointIP(const std::string& destinationEndpointIP)
{
destinationEndpointIP_ = destinationEndpointIP;
setCoreParameter("DestinationEndpointIP", destinationEndpointIP);
}
std::string CreateRestoreTaskRequest::getRegionId()const
{
return regionId_;
}
void CreateRestoreTaskRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointDatabaseName()const
{
return destinationEndpointDatabaseName_;
}
void CreateRestoreTaskRequest::setDestinationEndpointDatabaseName(const std::string& destinationEndpointDatabaseName)
{
destinationEndpointDatabaseName_ = destinationEndpointDatabaseName;
setCoreParameter("DestinationEndpointDatabaseName", destinationEndpointDatabaseName);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointUserName()const
{
return destinationEndpointUserName_;
@@ -223,6 +113,105 @@ void CreateRestoreTaskRequest::setRestoreTaskName(const std::string& restoreTask
setCoreParameter("RestoreTaskName", restoreTaskName);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointOracleSID()const
{
return destinationEndpointOracleSID_;
}
void CreateRestoreTaskRequest::setDestinationEndpointOracleSID(const std::string& destinationEndpointOracleSID)
{
destinationEndpointOracleSID_ = destinationEndpointOracleSID;
setCoreParameter("DestinationEndpointOracleSID", destinationEndpointOracleSID);
}
long CreateRestoreTaskRequest::getRestoreTime()const
{
return restoreTime_;
}
void CreateRestoreTaskRequest::setRestoreTime(long restoreTime)
{
restoreTime_ = restoreTime;
setCoreParameter("RestoreTime", std::to_string(restoreTime));
}
std::string CreateRestoreTaskRequest::getDestinationEndpointInstanceID()const
{
return destinationEndpointInstanceID_;
}
void CreateRestoreTaskRequest::setDestinationEndpointInstanceID(const std::string& destinationEndpointInstanceID)
{
destinationEndpointInstanceID_ = destinationEndpointInstanceID;
setCoreParameter("DestinationEndpointInstanceID", destinationEndpointInstanceID);
}
int CreateRestoreTaskRequest::getDestinationEndpointPort()const
{
return destinationEndpointPort_;
}
void CreateRestoreTaskRequest::setDestinationEndpointPort(int destinationEndpointPort)
{
destinationEndpointPort_ = destinationEndpointPort;
setCoreParameter("DestinationEndpointPort", std::to_string(destinationEndpointPort));
}
std::string CreateRestoreTaskRequest::getBackupSetId()const
{
return backupSetId_;
}
void CreateRestoreTaskRequest::setBackupSetId(const std::string& backupSetId)
{
backupSetId_ = backupSetId;
setCoreParameter("BackupSetId", backupSetId);
}
std::string CreateRestoreTaskRequest::getOwnerId()const
{
return ownerId_;
}
void CreateRestoreTaskRequest::setOwnerId(const std::string& ownerId)
{
ownerId_ = ownerId;
setCoreParameter("OwnerId", ownerId);
}
std::string CreateRestoreTaskRequest::getRestoreDir()const
{
return restoreDir_;
}
void CreateRestoreTaskRequest::setRestoreDir(const std::string& restoreDir)
{
restoreDir_ = restoreDir;
setCoreParameter("RestoreDir", restoreDir);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointIP()const
{
return destinationEndpointIP_;
}
void CreateRestoreTaskRequest::setDestinationEndpointIP(const std::string& destinationEndpointIP)
{
destinationEndpointIP_ = destinationEndpointIP;
setCoreParameter("DestinationEndpointIP", destinationEndpointIP);
}
std::string CreateRestoreTaskRequest::getDestinationEndpointDatabaseName()const
{
return destinationEndpointDatabaseName_;
}
void CreateRestoreTaskRequest::setDestinationEndpointDatabaseName(const std::string& destinationEndpointDatabaseName)
{
destinationEndpointDatabaseName_ = destinationEndpointDatabaseName;
setCoreParameter("DestinationEndpointDatabaseName", destinationEndpointDatabaseName);
}
std::string CreateRestoreTaskRequest::getDuplicateConflict()const
{
return duplicateConflict_;

8
dbs/src/model/CreateRestoreTaskResult.cc
View File

@@ -35,13 +35,9 @@ CreateRestoreTaskResult::~CreateRestoreTaskResult()
void CreateRestoreTaskResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

55
dbs/src/model/DescribeBackupGatewayListRequest.cc
View File

@@ -36,17 +36,6 @@ void DescribeBackupGatewayListRequest::setIdentifier(const std::string& identifi
setCoreParameter("Identifier", identifier);
}
std::string DescribeBackupGatewayListRequest::getRegionId()const
{
return regionId_;
}
void DescribeBackupGatewayListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeBackupGatewayListRequest::getClientToken()const
{
return clientToken_;
@@ -58,28 +47,6 @@ void DescribeBackupGatewayListRequest::setClientToken(const std::string& clientT
setCoreParameter("ClientToken", clientToken);
}
int DescribeBackupGatewayListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupGatewayListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupGatewayListRequest::getRegion()const
{
return region_;
}
void DescribeBackupGatewayListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}
int DescribeBackupGatewayListRequest::getPageNum()const
{
return pageNum_;
@@ -102,3 +69,25 @@ void DescribeBackupGatewayListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
int DescribeBackupGatewayListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupGatewayListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupGatewayListRequest::getRegion()const
{
return region_;
}
void DescribeBackupGatewayListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}

8
dbs/src/model/DescribeBackupGatewayListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeBackupGatewayListResult::~DescribeBackupGatewayListResult()
void DescribeBackupGatewayListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["BackupGateway"];
for (auto value : allItems)

55
dbs/src/model/DescribeBackupPlanListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeBackupPlanListRequest::DescribeBackupPlanListRequest() :
DescribeBackupPlanListRequest::~DescribeBackupPlanListRequest()
{}
std::string DescribeBackupPlanListRequest::getRegionId()const
{
return regionId_;
}
void DescribeBackupPlanListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeBackupPlanListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribeBackupPlanListRequest::setClientToken(const std::string& clientToke
setCoreParameter("ClientToken", clientToken);
}
int DescribeBackupPlanListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupPlanListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupPlanListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -69,17 +47,6 @@ void DescribeBackupPlanListRequest::setBackupPlanId(const std::string& backupPla
setCoreParameter("BackupPlanId", backupPlanId);
}
std::string DescribeBackupPlanListRequest::getRegion()const
{
return region_;
}
void DescribeBackupPlanListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}
int DescribeBackupPlanListRequest::getPageNum()const
{
return pageNum_;
@@ -102,3 +69,25 @@ void DescribeBackupPlanListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
int DescribeBackupPlanListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeBackupPlanListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeBackupPlanListRequest::getRegion()const
{
return region_;
}
void DescribeBackupPlanListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}

8
dbs/src/model/DescribeBackupPlanListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeBackupPlanListResult::~DescribeBackupPlanListResult()
void DescribeBackupPlanListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["BackupPlanDetail"];
for (auto value : allItems)

33
dbs/src/model/DescribeFullBackupListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeFullBackupListRequest::DescribeFullBackupListRequest() :
DescribeFullBackupListRequest::~DescribeFullBackupListRequest()
{}
std::string DescribeFullBackupListRequest::getRegionId()const
{
return regionId_;
}
void DescribeFullBackupListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeFullBackupListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribeFullBackupListRequest::setClientToken(const std::string& clientToke
setCoreParameter("ClientToken", clientToken);
}
int DescribeFullBackupListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeFullBackupListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeFullBackupListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -91,3 +69,14 @@ void DescribeFullBackupListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
int DescribeFullBackupListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeFullBackupListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}

8
dbs/src/model/DescribeFullBackupListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeFullBackupListResult::~DescribeFullBackupListResult()
void DescribeFullBackupListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["FullBackupFile"];
for (auto value : allItems)

33
dbs/src/model/DescribeIncrementBackupListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeIncrementBackupListRequest::DescribeIncrementBackupListRequest() :
DescribeIncrementBackupListRequest::~DescribeIncrementBackupListRequest()
{}
std::string DescribeIncrementBackupListRequest::getRegionId()const
{
return regionId_;
}
void DescribeIncrementBackupListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeIncrementBackupListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribeIncrementBackupListRequest::setClientToken(const std::string& clien
setCoreParameter("ClientToken", clientToken);
}
int DescribeIncrementBackupListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeIncrementBackupListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeIncrementBackupListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -91,3 +69,14 @@ void DescribeIncrementBackupListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
int DescribeIncrementBackupListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeIncrementBackupListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}

8
dbs/src/model/DescribeIncrementBackupListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeIncrementBackupListResult::~DescribeIncrementBackupListResult()
void DescribeIncrementBackupListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["IncrementBackupFile"];
for (auto value : allItems)

33
dbs/src/model/DescribeNodeCidrListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeNodeCidrListRequest::DescribeNodeCidrListRequest() :
DescribeNodeCidrListRequest::~DescribeNodeCidrListRequest()
{}
std::string DescribeNodeCidrListRequest::getRegionId()const
{
return regionId_;
}
void DescribeNodeCidrListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeNodeCidrListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribeNodeCidrListRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string DescribeNodeCidrListRequest::getRegion()const
{
return region_;
}
void DescribeNodeCidrListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}
std::string DescribeNodeCidrListRequest::getOwnerId()const
{
return ownerId_;
@@ -69,3 +47,14 @@ void DescribeNodeCidrListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string DescribeNodeCidrListRequest::getRegion()const
{
return region_;
}
void DescribeNodeCidrListRequest::setRegion(const std::string& region)
{
region_ = region;
setCoreParameter("Region", region);
}

8
dbs/src/model/DescribeNodeCidrListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeNodeCidrListResult::~DescribeNodeCidrListResult()
void DescribeNodeCidrListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allInternetIPs = value["InternetIPs"]["InternetIP"];
for (const auto &item : allInternetIPs)

33
dbs/src/model/DescribePreCheckProgressListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribePreCheckProgressListRequest::DescribePreCheckProgressListRequest() :
DescribePreCheckProgressListRequest::~DescribePreCheckProgressListRequest()
{}
std::string DescribePreCheckProgressListRequest::getRegionId()const
{
return regionId_;
}
void DescribePreCheckProgressListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribePreCheckProgressListRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void DescribePreCheckProgressListRequest::setClientToken(const std::string& clie
setCoreParameter("ClientToken", clientToken);
}
std::string DescribePreCheckProgressListRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void DescribePreCheckProgressListRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}
std::string DescribePreCheckProgressListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -80,3 +58,14 @@ void DescribePreCheckProgressListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string DescribePreCheckProgressListRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void DescribePreCheckProgressListRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}

8
dbs/src/model/DescribePreCheckProgressListResult.cc
View File

@@ -35,13 +35,9 @@ DescribePreCheckProgressListResult::~DescribePreCheckProgressListResult()
void DescribePreCheckProgressListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["PreCheckProgressDetail"];
for (auto value : allItems)

55
dbs/src/model/DescribeRestoreTaskListRequest.cc
View File

@@ -25,17 +25,6 @@ DescribeRestoreTaskListRequest::DescribeRestoreTaskListRequest() :
DescribeRestoreTaskListRequest::~DescribeRestoreTaskListRequest()
{}
std::string DescribeRestoreTaskListRequest::getRegionId()const
{
return regionId_;
}
void DescribeRestoreTaskListRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string DescribeRestoreTaskListRequest::getClientToken()const
{
return clientToken_;
@@ -47,28 +36,6 @@ void DescribeRestoreTaskListRequest::setClientToken(const std::string& clientTok
setCoreParameter("ClientToken", clientToken);
}
std::string DescribeRestoreTaskListRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void DescribeRestoreTaskListRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}
int DescribeRestoreTaskListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeRestoreTaskListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeRestoreTaskListRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -102,3 +69,25 @@ void DescribeRestoreTaskListRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string DescribeRestoreTaskListRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void DescribeRestoreTaskListRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}
int DescribeRestoreTaskListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeRestoreTaskListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setCoreParameter("PageSize", std::to_string(pageSize));
}

8
dbs/src/model/DescribeRestoreTaskListResult.cc
View File

@@ -35,13 +35,9 @@ DescribeRestoreTaskListResult::~DescribeRestoreTaskListResult()
void DescribeRestoreTaskListResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItems = value["Items"]["RestoreTaskDetail"];
for (auto value : allItems)

11
dbs/src/model/ModifyBackupObjectsRequest.cc
View File

@@ -25,17 +25,6 @@ ModifyBackupObjectsRequest::ModifyBackupObjectsRequest() :
ModifyBackupObjectsRequest::~ModifyBackupObjectsRequest()
{}
std::string ModifyBackupObjectsRequest::getRegionId()const
{
return regionId_;
}
void ModifyBackupObjectsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ModifyBackupObjectsRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/ModifyBackupObjectsResult.cc
View File

@@ -35,13 +35,9 @@ ModifyBackupObjectsResult::~ModifyBackupObjectsResult()
void ModifyBackupObjectsResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

33
dbs/src/model/ModifyBackupPlanNameRequest.cc
View File

@@ -25,28 +25,6 @@ ModifyBackupPlanNameRequest::ModifyBackupPlanNameRequest() :
ModifyBackupPlanNameRequest::~ModifyBackupPlanNameRequest()
{}
std::string ModifyBackupPlanNameRequest::getBackupPlanName()const
{
return backupPlanName_;
}
void ModifyBackupPlanNameRequest::setBackupPlanName(const std::string& backupPlanName)
{
backupPlanName_ = backupPlanName;
setCoreParameter("BackupPlanName", backupPlanName);
}
std::string ModifyBackupPlanNameRequest::getRegionId()const
{
return regionId_;
}
void ModifyBackupPlanNameRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ModifyBackupPlanNameRequest::getClientToken()const
{
return clientToken_;
@@ -80,3 +58,14 @@ void ModifyBackupPlanNameRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string ModifyBackupPlanNameRequest::getBackupPlanName()const
{
return backupPlanName_;
}
void ModifyBackupPlanNameRequest::setBackupPlanName(const std::string& backupPlanName)
{
backupPlanName_ = backupPlanName;
setCoreParameter("BackupPlanName", backupPlanName);
}

8
dbs/src/model/ModifyBackupPlanNameResult.cc
View File

@@ -35,13 +35,9 @@ ModifyBackupPlanNameResult::~ModifyBackupPlanNameResult()
void ModifyBackupPlanNameResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

77
dbs/src/model/ModifyBackupSourceEndpointRequest.cc
View File

@@ -80,17 +80,6 @@ void ModifyBackupSourceEndpointRequest::setClientToken(const std::string& client
setCoreParameter("ClientToken", clientToken);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointPassword()const
{
return sourceEndpointPassword_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointPassword(const std::string& sourceEndpointPassword)
{
sourceEndpointPassword_ = sourceEndpointPassword;
setCoreParameter("SourceEndpointPassword", sourceEndpointPassword);
}
std::string ModifyBackupSourceEndpointRequest::getBackupPlanId()const
{
return backupPlanId_;
@@ -102,6 +91,39 @@ void ModifyBackupSourceEndpointRequest::setBackupPlanId(const std::string& backu
setCoreParameter("BackupPlanId", backupPlanId);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointDatabaseName()const
{
return sourceEndpointDatabaseName_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName)
{
sourceEndpointDatabaseName_ = sourceEndpointDatabaseName;
setCoreParameter("SourceEndpointDatabaseName", sourceEndpointDatabaseName);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointIP()const
{
return sourceEndpointIP_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointIP(const std::string& sourceEndpointIP)
{
sourceEndpointIP_ = sourceEndpointIP;
setCoreParameter("SourceEndpointIP", sourceEndpointIP);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointPassword()const
{
return sourceEndpointPassword_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointPassword(const std::string& sourceEndpointPassword)
{
sourceEndpointPassword_ = sourceEndpointPassword;
setCoreParameter("SourceEndpointPassword", sourceEndpointPassword);
}
std::string ModifyBackupSourceEndpointRequest::getBackupObjects()const
{
return backupObjects_;
@@ -135,17 +157,6 @@ void ModifyBackupSourceEndpointRequest::setSourceEndpointPort(int sourceEndpoint
setCoreParameter("SourceEndpointPort", std::to_string(sourceEndpointPort));
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointDatabaseName()const
{
return sourceEndpointDatabaseName_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointDatabaseName(const std::string& sourceEndpointDatabaseName)
{
sourceEndpointDatabaseName_ = sourceEndpointDatabaseName;
setCoreParameter("SourceEndpointDatabaseName", sourceEndpointDatabaseName);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointInstanceType()const
{
return sourceEndpointInstanceType_;
@@ -157,28 +168,6 @@ void ModifyBackupSourceEndpointRequest::setSourceEndpointInstanceType(const std:
setCoreParameter("SourceEndpointInstanceType", sourceEndpointInstanceType);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointIP()const
{
return sourceEndpointIP_;
}
void ModifyBackupSourceEndpointRequest::setSourceEndpointIP(const std::string& sourceEndpointIP)
{
sourceEndpointIP_ = sourceEndpointIP;
setCoreParameter("SourceEndpointIP", sourceEndpointIP);
}
std::string ModifyBackupSourceEndpointRequest::getRegionId()const
{
return regionId_;
}
void ModifyBackupSourceEndpointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ModifyBackupSourceEndpointRequest::getSourceEndpointOracleSID()const
{
return sourceEndpointOracleSID_;

8
dbs/src/model/ModifyBackupSourceEndpointResult.cc
View File

@@ -35,13 +35,9 @@ ModifyBackupSourceEndpointResult::~ModifyBackupSourceEndpointResult()
void ModifyBackupSourceEndpointResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

55
dbs/src/model/ModifyBackupStrategyRequest.cc
View File

@@ -25,39 +25,6 @@ ModifyBackupStrategyRequest::ModifyBackupStrategyRequest() :
ModifyBackupStrategyRequest::~ModifyBackupStrategyRequest()
{}
std::string ModifyBackupStrategyRequest::getBackupPeriod()const
{
return backupPeriod_;
}
void ModifyBackupStrategyRequest::setBackupPeriod(const std::string& backupPeriod)
{
backupPeriod_ = backupPeriod;
setCoreParameter("BackupPeriod", backupPeriod);
}
std::string ModifyBackupStrategyRequest::getBackupStartTime()const
{
return backupStartTime_;
}
void ModifyBackupStrategyRequest::setBackupStartTime(const std::string& backupStartTime)
{
backupStartTime_ = backupStartTime;
setCoreParameter("BackupStartTime", backupStartTime);
}
std::string ModifyBackupStrategyRequest::getRegionId()const
{
return regionId_;
}
void ModifyBackupStrategyRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string ModifyBackupStrategyRequest::getClientToken()const
{
return clientToken_;
@@ -91,3 +58,25 @@ void ModifyBackupStrategyRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string ModifyBackupStrategyRequest::getBackupPeriod()const
{
return backupPeriod_;
}
void ModifyBackupStrategyRequest::setBackupPeriod(const std::string& backupPeriod)
{
backupPeriod_ = backupPeriod;
setCoreParameter("BackupPeriod", backupPeriod);
}
std::string ModifyBackupStrategyRequest::getBackupStartTime()const
{
return backupStartTime_;
}
void ModifyBackupStrategyRequest::setBackupStartTime(const std::string& backupStartTime)
{
backupStartTime_ = backupStartTime;
setCoreParameter("BackupStartTime", backupStartTime);
}

8
dbs/src/model/ModifyBackupStrategyResult.cc
View File

@@ -35,13 +35,9 @@ ModifyBackupStrategyResult::~ModifyBackupStrategyResult()
void ModifyBackupStrategyResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

11
dbs/src/model/RenewBackupPlanRequest.cc
View File

@@ -36,17 +36,6 @@ void RenewBackupPlanRequest::setPeriod(const std::string& period)
setCoreParameter("Period", period);
}
std::string RenewBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void RenewBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string RenewBackupPlanRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/RenewBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ RenewBackupPlanResult::~RenewBackupPlanResult()
void RenewBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

11
dbs/src/model/StartBackupPlanRequest.cc
View File

@@ -25,17 +25,6 @@ StartBackupPlanRequest::StartBackupPlanRequest() :
StartBackupPlanRequest::~StartBackupPlanRequest()
{}
std::string StartBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void StartBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string StartBackupPlanRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/StartBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ StartBackupPlanResult::~StartBackupPlanResult()
void StartBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

33
dbs/src/model/StartRestoreTaskRequest.cc
View File

@@ -25,17 +25,6 @@ StartRestoreTaskRequest::StartRestoreTaskRequest() :
StartRestoreTaskRequest::~StartRestoreTaskRequest()
{}
std::string StartRestoreTaskRequest::getRegionId()const
{
return regionId_;
}
void StartRestoreTaskRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string StartRestoreTaskRequest::getClientToken()const
{
return clientToken_;
@@ -47,17 +36,6 @@ void StartRestoreTaskRequest::setClientToken(const std::string& clientToken)
setCoreParameter("ClientToken", clientToken);
}
std::string StartRestoreTaskRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void StartRestoreTaskRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}
std::string StartRestoreTaskRequest::getOwnerId()const
{
return ownerId_;
@@ -69,3 +47,14 @@ void StartRestoreTaskRequest::setOwnerId(const std::string& ownerId)
setCoreParameter("OwnerId", ownerId);
}
std::string StartRestoreTaskRequest::getRestoreTaskId()const
{
return restoreTaskId_;
}
void StartRestoreTaskRequest::setRestoreTaskId(const std::string& restoreTaskId)
{
restoreTaskId_ = restoreTaskId;
setCoreParameter("RestoreTaskId", restoreTaskId);
}

8
dbs/src/model/StartRestoreTaskResult.cc
View File

@@ -35,13 +35,9 @@ StartRestoreTaskResult::~StartRestoreTaskResult()
void StartRestoreTaskResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

11
dbs/src/model/StopBackupPlanRequest.cc
View File

@@ -36,17 +36,6 @@ void StopBackupPlanRequest::setStopMethod(const std::string& stopMethod)
setCoreParameter("StopMethod", stopMethod);
}
std::string StopBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void StopBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string StopBackupPlanRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/StopBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ StopBackupPlanResult::~StopBackupPlanResult()
void StopBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";

11
dbs/src/model/UpgradeBackupPlanRequest.cc
View File

@@ -25,17 +25,6 @@ UpgradeBackupPlanRequest::UpgradeBackupPlanRequest() :
UpgradeBackupPlanRequest::~UpgradeBackupPlanRequest()
{}
std::string UpgradeBackupPlanRequest::getRegionId()const
{
return regionId_;
}
void UpgradeBackupPlanRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setCoreParameter("RegionId", regionId);
}
std::string UpgradeBackupPlanRequest::getClientToken()const
{
return clientToken_;

8
dbs/src/model/UpgradeBackupPlanResult.cc
View File

@@ -35,13 +35,9 @@ UpgradeBackupPlanResult::~UpgradeBackupPlanResult()
void UpgradeBackupPlanResult::parse(const std::string &payload)
{
Json::CharReaderBuilder builder;
Json::CharReader *reader = builder.newCharReader();
Json::Value *val;
Json::Reader reader;
Json::Value value;
JSONCPP_STRING *errs;
reader->parse(payload.data(), payload.data() + payload.size(), val, errs);
value = *val;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";