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

Supported RunInstances specifiy Dedicated Host Cluster Id.

Browse Source
This commit is contained in:
sdk-team
2021-01-21 04:16:31 +00:00
parent 0802c5d8b0
commit 65a6e6b64f
104 changed files with 8251 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

756
ecs/src/EcsClient.cc
View File

@@ -807,6 +807,42 @@ EcsClient::CancelCopyImageOutcomeCallable EcsClient::cancelCopyImageCallable(con
return task->get_future();
}
EcsClient::CancelImagePipelineExecutionOutcome EcsClient::cancelImagePipelineExecution(const CancelImagePipelineExecutionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CancelImagePipelineExecutionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CancelImagePipelineExecutionOutcome(CancelImagePipelineExecutionResult(outcome.result()));
else
return CancelImagePipelineExecutionOutcome(outcome.error());
}
void EcsClient::cancelImagePipelineExecutionAsync(const CancelImagePipelineExecutionRequest& request, const CancelImagePipelineExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, cancelImagePipelineExecution(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::CancelImagePipelineExecutionOutcomeCallable EcsClient::cancelImagePipelineExecutionCallable(const CancelImagePipelineExecutionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CancelImagePipelineExecutionOutcome()>>(
[this, request]()
{
return this->cancelImagePipelineExecution(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::CancelPhysicalConnectionOutcome EcsClient::cancelPhysicalConnection(const CancelPhysicalConnectionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,6 +1095,42 @@ EcsClient::CopySnapshotOutcomeCallable EcsClient::copySnapshotCallable(const Cop
return task->get_future();
}
EcsClient::CreateActivationOutcome EcsClient::createActivation(const CreateActivationRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateActivationOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateActivationOutcome(CreateActivationResult(outcome.result()));
else
return CreateActivationOutcome(outcome.error());
}
void EcsClient::createActivationAsync(const CreateActivationRequest& request, const CreateActivationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createActivation(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::CreateActivationOutcomeCallable EcsClient::createActivationCallable(const CreateActivationRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateActivationOutcome()>>(
[this, request]()
{
return this->createActivation(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::CreateAutoProvisioningGroupOutcome EcsClient::createAutoProvisioningGroup(const CreateAutoProvisioningGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1527,6 +1599,78 @@ EcsClient::CreateImageOutcomeCallable EcsClient::createImageCallable(const Creat
return task->get_future();
}
EcsClient::CreateImageComponentOutcome EcsClient::createImageComponent(const CreateImageComponentRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateImageComponentOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateImageComponentOutcome(CreateImageComponentResult(outcome.result()));
else
return CreateImageComponentOutcome(outcome.error());
}
void EcsClient::createImageComponentAsync(const CreateImageComponentRequest& request, const CreateImageComponentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createImageComponent(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::CreateImageComponentOutcomeCallable EcsClient::createImageComponentCallable(const CreateImageComponentRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateImageComponentOutcome()>>(
[this, request]()
{
return this->createImageComponent(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::CreateImagePipelineOutcome EcsClient::createImagePipeline(const CreateImagePipelineRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateImagePipelineOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateImagePipelineOutcome(CreateImagePipelineResult(outcome.result()));
else
return CreateImagePipelineOutcome(outcome.error());
}
void EcsClient::createImagePipelineAsync(const CreateImagePipelineRequest& request, const CreateImagePipelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createImagePipeline(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::CreateImagePipelineOutcomeCallable EcsClient::createImagePipelineCallable(const CreateImagePipelineRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateImagePipelineOutcome()>>(
[this, request]()
{
return this->createImagePipeline(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::CreateInstanceOutcome EcsClient::createInstance(const CreateInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1995,6 +2139,42 @@ EcsClient::CreateSnapshotOutcomeCallable EcsClient::createSnapshotCallable(const
return task->get_future();
}
EcsClient::CreateSnapshotGroupOutcome EcsClient::createSnapshotGroup(const CreateSnapshotGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateSnapshotGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateSnapshotGroupOutcome(CreateSnapshotGroupResult(outcome.result()));
else
return CreateSnapshotGroupOutcome(outcome.error());
}
void EcsClient::createSnapshotGroupAsync(const CreateSnapshotGroupRequest& request, const CreateSnapshotGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createSnapshotGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::CreateSnapshotGroupOutcomeCallable EcsClient::createSnapshotGroupCallable(const CreateSnapshotGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateSnapshotGroupOutcome()>>(
[this, request]()
{
return this->createSnapshotGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::CreateStorageSetOutcome EcsClient::createStorageSet(const CreateStorageSetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2175,6 +2355,42 @@ EcsClient::DeactivateRouterInterfaceOutcomeCallable EcsClient::deactivateRouterI
return task->get_future();
}
EcsClient::DeleteActivationOutcome EcsClient::deleteActivation(const DeleteActivationRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteActivationOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteActivationOutcome(DeleteActivationResult(outcome.result()));
else
return DeleteActivationOutcome(outcome.error());
}
void EcsClient::deleteActivationAsync(const DeleteActivationRequest& request, const DeleteActivationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteActivation(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DeleteActivationOutcomeCallable EcsClient::deleteActivationCallable(const DeleteActivationRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteActivationOutcome()>>(
[this, request]()
{
return this->deleteActivation(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DeleteAutoProvisioningGroupOutcome EcsClient::deleteAutoProvisioningGroup(const DeleteAutoProvisioningGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2607,6 +2823,78 @@ EcsClient::DeleteImageOutcomeCallable EcsClient::deleteImageCallable(const Delet
return task->get_future();
}
EcsClient::DeleteImageComponentOutcome EcsClient::deleteImageComponent(const DeleteImageComponentRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteImageComponentOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteImageComponentOutcome(DeleteImageComponentResult(outcome.result()));
else
return DeleteImageComponentOutcome(outcome.error());
}
void EcsClient::deleteImageComponentAsync(const DeleteImageComponentRequest& request, const DeleteImageComponentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteImageComponent(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DeleteImageComponentOutcomeCallable EcsClient::deleteImageComponentCallable(const DeleteImageComponentRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteImageComponentOutcome()>>(
[this, request]()
{
return this->deleteImageComponent(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DeleteImagePipelineOutcome EcsClient::deleteImagePipeline(const DeleteImagePipelineRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteImagePipelineOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteImagePipelineOutcome(DeleteImagePipelineResult(outcome.result()));
else
return DeleteImagePipelineOutcome(outcome.error());
}
void EcsClient::deleteImagePipelineAsync(const DeleteImagePipelineRequest& request, const DeleteImagePipelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteImagePipeline(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DeleteImagePipelineOutcomeCallable EcsClient::deleteImagePipelineCallable(const DeleteImagePipelineRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteImagePipelineOutcome()>>(
[this, request]()
{
return this->deleteImagePipeline(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DeleteInstanceOutcome EcsClient::deleteInstance(const DeleteInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3075,6 +3363,42 @@ EcsClient::DeleteSnapshotOutcomeCallable EcsClient::deleteSnapshotCallable(const
return task->get_future();
}
EcsClient::DeleteSnapshotGroupOutcome EcsClient::deleteSnapshotGroup(const DeleteSnapshotGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteSnapshotGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteSnapshotGroupOutcome(DeleteSnapshotGroupResult(outcome.result()));
else
return DeleteSnapshotGroupOutcome(outcome.error());
}
void EcsClient::deleteSnapshotGroupAsync(const DeleteSnapshotGroupRequest& request, const DeleteSnapshotGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteSnapshotGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DeleteSnapshotGroupOutcomeCallable EcsClient::deleteSnapshotGroupCallable(const DeleteSnapshotGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteSnapshotGroupOutcome()>>(
[this, request]()
{
return this->deleteSnapshotGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DeleteStorageSetOutcome EcsClient::deleteStorageSet(const DeleteStorageSetRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3219,6 +3543,42 @@ EcsClient::DeleteVpcOutcomeCallable EcsClient::deleteVpcCallable(const DeleteVpc
return task->get_future();
}
EcsClient::DeregisterManagedInstanceOutcome EcsClient::deregisterManagedInstance(const DeregisterManagedInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeregisterManagedInstanceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeregisterManagedInstanceOutcome(DeregisterManagedInstanceResult(outcome.result()));
else
return DeregisterManagedInstanceOutcome(outcome.error());
}
void EcsClient::deregisterManagedInstanceAsync(const DeregisterManagedInstanceRequest& request, const DeregisterManagedInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deregisterManagedInstance(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DeregisterManagedInstanceOutcomeCallable EcsClient::deregisterManagedInstanceCallable(const DeregisterManagedInstanceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeregisterManagedInstanceOutcome()>>(
[this, request]()
{
return this->deregisterManagedInstance(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeAccessPointsOutcome EcsClient::describeAccessPoints(const DescribeAccessPointsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3291,6 +3651,42 @@ EcsClient::DescribeAccountAttributesOutcomeCallable EcsClient::describeAccountAt
return task->get_future();
}
EcsClient::DescribeActivationsOutcome EcsClient::describeActivations(const DescribeActivationsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeActivationsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeActivationsOutcome(DescribeActivationsResult(outcome.result()));
else
return DescribeActivationsOutcome(outcome.error());
}
void EcsClient::describeActivationsAsync(const DescribeActivationsRequest& request, const DescribeActivationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeActivations(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeActivationsOutcomeCallable EcsClient::describeActivationsCallable(const DescribeActivationsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeActivationsOutcome()>>(
[this, request]()
{
return this->describeActivations(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeAutoProvisioningGroupHistoryOutcome EcsClient::describeAutoProvisioningGroupHistory(const DescribeAutoProvisioningGroupHistoryRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4407,6 +4803,42 @@ EcsClient::DescribeHpcClustersOutcomeCallable EcsClient::describeHpcClustersCall
return task->get_future();
}
EcsClient::DescribeImageComponentsOutcome EcsClient::describeImageComponents(const DescribeImageComponentsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeImageComponentsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeImageComponentsOutcome(DescribeImageComponentsResult(outcome.result()));
else
return DescribeImageComponentsOutcome(outcome.error());
}
void EcsClient::describeImageComponentsAsync(const DescribeImageComponentsRequest& request, const DescribeImageComponentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeImageComponents(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeImageComponentsOutcomeCallable EcsClient::describeImageComponentsCallable(const DescribeImageComponentsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeImageComponentsOutcome()>>(
[this, request]()
{
return this->describeImageComponents(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeImageFromFamilyOutcome EcsClient::describeImageFromFamily(const DescribeImageFromFamilyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4443,6 +4875,78 @@ EcsClient::DescribeImageFromFamilyOutcomeCallable EcsClient::describeImageFromFa
return task->get_future();
}
EcsClient::DescribeImagePipelineExecutionsOutcome EcsClient::describeImagePipelineExecutions(const DescribeImagePipelineExecutionsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeImagePipelineExecutionsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeImagePipelineExecutionsOutcome(DescribeImagePipelineExecutionsResult(outcome.result()));
else
return DescribeImagePipelineExecutionsOutcome(outcome.error());
}
void EcsClient::describeImagePipelineExecutionsAsync(const DescribeImagePipelineExecutionsRequest& request, const DescribeImagePipelineExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeImagePipelineExecutions(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeImagePipelineExecutionsOutcomeCallable EcsClient::describeImagePipelineExecutionsCallable(const DescribeImagePipelineExecutionsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeImagePipelineExecutionsOutcome()>>(
[this, request]()
{
return this->describeImagePipelineExecutions(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeImagePipelinesOutcome EcsClient::describeImagePipelines(const DescribeImagePipelinesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeImagePipelinesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeImagePipelinesOutcome(DescribeImagePipelinesResult(outcome.result()));
else
return DescribeImagePipelinesOutcome(outcome.error());
}
void EcsClient::describeImagePipelinesAsync(const DescribeImagePipelinesRequest& request, const DescribeImagePipelinesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeImagePipelines(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeImagePipelinesOutcomeCallable EcsClient::describeImagePipelinesCallable(const DescribeImagePipelinesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeImagePipelinesOutcome()>>(
[this, request]()
{
return this->describeImagePipelines(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeImageSharePermissionOutcome EcsClient::describeImageSharePermission(const DescribeImageSharePermissionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5307,6 +5811,42 @@ EcsClient::DescribeLimitationOutcomeCallable EcsClient::describeLimitationCallab
return task->get_future();
}
EcsClient::DescribeManagedInstancesOutcome EcsClient::describeManagedInstances(const DescribeManagedInstancesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeManagedInstancesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeManagedInstancesOutcome(DescribeManagedInstancesResult(outcome.result()));
else
return DescribeManagedInstancesOutcome(outcome.error());
}
void EcsClient::describeManagedInstancesAsync(const DescribeManagedInstancesRequest& request, const DescribeManagedInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeManagedInstances(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeManagedInstancesOutcomeCallable EcsClient::describeManagedInstancesCallable(const DescribeManagedInstancesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeManagedInstancesOutcome()>>(
[this, request]()
{
return this->describeManagedInstances(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeNatGatewaysOutcome EcsClient::describeNatGateways(const DescribeNatGatewaysRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5991,6 +6531,42 @@ EcsClient::DescribeSendFileResultsOutcomeCallable EcsClient::describeSendFileRes
return task->get_future();
}
EcsClient::DescribeSnapshotGroupsOutcome EcsClient::describeSnapshotGroups(const DescribeSnapshotGroupsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeSnapshotGroupsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeSnapshotGroupsOutcome(DescribeSnapshotGroupsResult(outcome.result()));
else
return DescribeSnapshotGroupsOutcome(outcome.error());
}
void EcsClient::describeSnapshotGroupsAsync(const DescribeSnapshotGroupsRequest& request, const DescribeSnapshotGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeSnapshotGroups(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DescribeSnapshotGroupsOutcomeCallable EcsClient::describeSnapshotGroupsCallable(const DescribeSnapshotGroupsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeSnapshotGroupsOutcome()>>(
[this, request]()
{
return this->describeSnapshotGroups(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::DescribeSnapshotLinksOutcome EcsClient::describeSnapshotLinks(const DescribeSnapshotLinksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6927,6 +7503,42 @@ EcsClient::DetachNetworkInterfaceOutcomeCallable EcsClient::detachNetworkInterfa
return task->get_future();
}
EcsClient::DisableActivationOutcome EcsClient::disableActivation(const DisableActivationRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DisableActivationOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DisableActivationOutcome(DisableActivationResult(outcome.result()));
else
return DisableActivationOutcome(outcome.error());
}
void EcsClient::disableActivationAsync(const DisableActivationRequest& request, const DisableActivationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, disableActivation(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::DisableActivationOutcomeCallable EcsClient::disableActivationCallable(const DisableActivationRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DisableActivationOutcome()>>(
[this, request]()
{
return this->disableActivation(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::EipFillParamsOutcome EcsClient::eipFillParams(const EipFillParamsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -8871,6 +9483,42 @@ EcsClient::ModifyLaunchTemplateDefaultVersionOutcomeCallable EcsClient::modifyLa
return task->get_future();
}
EcsClient::ModifyManagedInstanceOutcome EcsClient::modifyManagedInstance(const ModifyManagedInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifyManagedInstanceOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifyManagedInstanceOutcome(ModifyManagedInstanceResult(outcome.result()));
else
return ModifyManagedInstanceOutcome(outcome.error());
}
void EcsClient::modifyManagedInstanceAsync(const ModifyManagedInstanceRequest& request, const ModifyManagedInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifyManagedInstance(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::ModifyManagedInstanceOutcomeCallable EcsClient::modifyManagedInstanceCallable(const ModifyManagedInstanceRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifyManagedInstanceOutcome()>>(
[this, request]()
{
return this->modifyManagedInstance(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::ModifyNetworkInterfaceAttributeOutcome EcsClient::modifyNetworkInterfaceAttribute(const ModifyNetworkInterfaceAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -9303,6 +9951,42 @@ EcsClient::ModifySnapshotAttributeOutcomeCallable EcsClient::modifySnapshotAttri
return task->get_future();
}
EcsClient::ModifySnapshotGroupOutcome EcsClient::modifySnapshotGroup(const ModifySnapshotGroupRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ModifySnapshotGroupOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ModifySnapshotGroupOutcome(ModifySnapshotGroupResult(outcome.result()));
else
return ModifySnapshotGroupOutcome(outcome.error());
}
void EcsClient::modifySnapshotGroupAsync(const ModifySnapshotGroupRequest& request, const ModifySnapshotGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, modifySnapshotGroup(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::ModifySnapshotGroupOutcomeCallable EcsClient::modifySnapshotGroupCallable(const ModifySnapshotGroupRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ModifySnapshotGroupOutcome()>>(
[this, request]()
{
return this->modifySnapshotGroup(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::ModifyStorageCapacityUnitAttributeOutcome EcsClient::modifyStorageCapacityUnitAttribute(const ModifyStorageCapacityUnitAttributeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10275,6 +10959,42 @@ EcsClient::ResetDiskOutcomeCallable EcsClient::resetDiskCallable(const ResetDisk
return task->get_future();
}
EcsClient::ResetDisksOutcome EcsClient::resetDisks(const ResetDisksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ResetDisksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ResetDisksOutcome(ResetDisksResult(outcome.result()));
else
return ResetDisksOutcome(outcome.error());
}
void EcsClient::resetDisksAsync(const ResetDisksRequest& request, const ResetDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, resetDisks(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::ResetDisksOutcomeCallable EcsClient::resetDisksCallable(const ResetDisksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ResetDisksOutcome()>>(
[this, request]()
{
return this->resetDisks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::ResizeDiskOutcome EcsClient::resizeDisk(const ResizeDiskRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10527,6 +11247,42 @@ EcsClient::StartElasticityAssuranceOutcomeCallable EcsClient::startElasticityAss
return task->get_future();
}
EcsClient::StartImagePipelineExecutionOutcome EcsClient::startImagePipelineExecution(const StartImagePipelineExecutionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return StartImagePipelineExecutionOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return StartImagePipelineExecutionOutcome(StartImagePipelineExecutionResult(outcome.result()));
else
return StartImagePipelineExecutionOutcome(outcome.error());
}
void EcsClient::startImagePipelineExecutionAsync(const StartImagePipelineExecutionRequest& request, const StartImagePipelineExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, startImagePipelineExecution(request), context);
};
asyncExecute(new Runnable(fn));
}
EcsClient::StartImagePipelineExecutionOutcomeCallable EcsClient::startImagePipelineExecutionCallable(const StartImagePipelineExecutionRequest &request) const
{
auto task = std::make_shared<std::packaged_task<StartImagePipelineExecutionOutcome()>>(
[this, request]()
{
return this->startImagePipelineExecution(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
EcsClient::StartInstanceOutcome EcsClient::startInstance(const StartInstanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

111
ecs/src/model/CancelImagePipelineExecutionRequest.cc Normal file
View File

@@ -0,0 +1,111 @@
/*
* 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/ecs/model/CancelImagePipelineExecutionRequest.h>
using AlibabaCloud::Ecs::Model::CancelImagePipelineExecutionRequest;
CancelImagePipelineExecutionRequest::CancelImagePipelineExecutionRequest() :
RpcServiceRequest("ecs", "2014-05-26", "CancelImagePipelineExecution")
{
setMethod(HttpRequest::Method::Post);
}
CancelImagePipelineExecutionRequest::~CancelImagePipelineExecutionRequest()
{}
long CancelImagePipelineExecutionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CancelImagePipelineExecutionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CancelImagePipelineExecutionRequest::getExecutionId()const
{
return executionId_;
}
void CancelImagePipelineExecutionRequest::setExecutionId(const std::string& executionId)
{
executionId_ = executionId;
setParameter("ExecutionId", executionId);
}
std::string CancelImagePipelineExecutionRequest::getRegionId()const
{
return regionId_;
}
void CancelImagePipelineExecutionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<CancelImagePipelineExecutionRequest::TemplateTag> CancelImagePipelineExecutionRequest::getTemplateTag()const
{
return templateTag_;
}
void CancelImagePipelineExecutionRequest::setTemplateTag(const std::vector<TemplateTag>& templateTag)
{
templateTag_ = templateTag;
for(int dep1 = 0; dep1!= templateTag.size(); dep1++) {
auto templateTagObj = templateTag.at(dep1);
std::string templateTagObjStr = "TemplateTag." + std::to_string(dep1 + 1);
setParameter(templateTagObjStr + ".Key", templateTagObj.key);
setParameter(templateTagObjStr + ".Value", templateTagObj.value);
}
}
std::string CancelImagePipelineExecutionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CancelImagePipelineExecutionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CancelImagePipelineExecutionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CancelImagePipelineExecutionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CancelImagePipelineExecutionRequest::getOwnerId()const
{
return ownerId_;
}
void CancelImagePipelineExecutionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

44
ecs/src/model/CancelImagePipelineExecutionResult.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/ecs/model/CancelImagePipelineExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
CancelImagePipelineExecutionResult::CancelImagePipelineExecutionResult() :
ServiceResult()
{}
CancelImagePipelineExecutionResult::CancelImagePipelineExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CancelImagePipelineExecutionResult::~CancelImagePipelineExecutionResult()
{}
void CancelImagePipelineExecutionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

139
ecs/src/model/CreateActivationRequest.cc Normal file
View File

@@ -0,0 +1,139 @@
/*
* 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/ecs/model/CreateActivationRequest.h>
using AlibabaCloud::Ecs::Model::CreateActivationRequest;
CreateActivationRequest::CreateActivationRequest() :
RpcServiceRequest("ecs", "2014-05-26", "CreateActivation")
{
setMethod(HttpRequest::Method::Post);
}
CreateActivationRequest::~CreateActivationRequest()
{}
long CreateActivationRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateActivationRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateActivationRequest::getDescription()const
{
return description_;
}
void CreateActivationRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string CreateActivationRequest::getRegionId()const
{
return regionId_;
}
void CreateActivationRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
int CreateActivationRequest::getInstanceCount()const
{
return instanceCount_;
}
void CreateActivationRequest::setInstanceCount(int instanceCount)
{
instanceCount_ = instanceCount;
setParameter("InstanceCount", std::to_string(instanceCount));
}
std::string CreateActivationRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateActivationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateActivationRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateActivationRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateActivationRequest::getOwnerId()const
{
return ownerId_;
}
void CreateActivationRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateActivationRequest::getInstanceName()const
{
return instanceName_;
}
void CreateActivationRequest::setInstanceName(const std::string& instanceName)
{
instanceName_ = instanceName;
setParameter("InstanceName", instanceName);
}
long CreateActivationRequest::getTimeToLiveInHours()const
{
return timeToLiveInHours_;
}
void CreateActivationRequest::setTimeToLiveInHours(long timeToLiveInHours)
{
timeToLiveInHours_ = timeToLiveInHours;
setParameter("TimeToLiveInHours", std::to_string(timeToLiveInHours));
}
std::string CreateActivationRequest::getIpAddressRange()const
{
return ipAddressRange_;
}
void CreateActivationRequest::setIpAddressRange(const std::string& ipAddressRange)
{
ipAddressRange_ = ipAddressRange;
setParameter("IpAddressRange", ipAddressRange);
}

58
ecs/src/model/CreateActivationResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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/ecs/model/CreateActivationResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
CreateActivationResult::CreateActivationResult() :
ServiceResult()
{}
CreateActivationResult::CreateActivationResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateActivationResult::~CreateActivationResult()
{}
void CreateActivationResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ActivationId"].isNull())
activationId_ = value["ActivationId"].asString();
if(!value["ActivationCode"].isNull())
activationCode_ = value["ActivationCode"].asString();
}
std::string CreateActivationResult::getActivationId()const
{
return activationId_;
}
std::string CreateActivationResult::getActivationCode()const
{
return activationCode_;
}

7
ecs/src/model/CreateDiskResult.cc
View File

@@ -41,9 +41,16 @@ void CreateDiskResult::parse(const std::string &payload)
setRequestId(value["RequestId"].asString());
if(!value["DiskId"].isNull())
diskId_ = value["DiskId"].asString();
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
}
std::string CreateDiskResult::getOrderId()const
{
return orderId_;
}
std::string CreateDiskResult::getDiskId()const
{
return diskId_;

177
ecs/src/model/CreateImageComponentRequest.cc Normal file
View File

@@ -0,0 +1,177 @@
/*
* 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/ecs/model/CreateImageComponentRequest.h>
using AlibabaCloud::Ecs::Model::CreateImageComponentRequest;
CreateImageComponentRequest::CreateImageComponentRequest() :
RpcServiceRequest("ecs", "2014-05-26", "CreateImageComponent")
{
setMethod(HttpRequest::Method::Post);
}
CreateImageComponentRequest::~CreateImageComponentRequest()
{}
long CreateImageComponentRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateImageComponentRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateImageComponentRequest::getClientToken()const
{
return clientToken_;
}
void CreateImageComponentRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateImageComponentRequest::getDescription()const
{
return description_;
}
void CreateImageComponentRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string CreateImageComponentRequest::getSystemType()const
{
return systemType_;
}
void CreateImageComponentRequest::setSystemType(const std::string& systemType)
{
systemType_ = systemType;
setParameter("SystemType", systemType);
}
std::string CreateImageComponentRequest::getContent()const
{
return content_;
}
void CreateImageComponentRequest::setContent(const std::string& content)
{
content_ = content;
setParameter("Content", content);
}
std::string CreateImageComponentRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CreateImageComponentRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CreateImageComponentRequest::getRegionId()const
{
return regionId_;
}
void CreateImageComponentRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<CreateImageComponentRequest::Tag> CreateImageComponentRequest::getTag()const
{
return tag_;
}
void CreateImageComponentRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Key", tagObj.key);
setParameter(tagObjStr + ".Value", tagObj.value);
}
}
std::string CreateImageComponentRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateImageComponentRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateImageComponentRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateImageComponentRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateImageComponentRequest::getOwnerId()const
{
return ownerId_;
}
void CreateImageComponentRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateImageComponentRequest::getComponentType()const
{
return componentType_;
}
void CreateImageComponentRequest::setComponentType(const std::string& componentType)
{
componentType_ = componentType;
setParameter("ComponentType", componentType);
}
std::string CreateImageComponentRequest::getName()const
{
return name_;
}
void CreateImageComponentRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

51
ecs/src/model/CreateImageComponentResult.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/ecs/model/CreateImageComponentResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
CreateImageComponentResult::CreateImageComponentResult() :
ServiceResult()
{}
CreateImageComponentResult::CreateImageComponentResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateImageComponentResult::~CreateImageComponentResult()
{}
void CreateImageComponentResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ImageComponentId"].isNull())
imageComponentId_ = value["ImageComponentId"].asString();
}
std::string CreateImageComponentResult::getImageComponentId()const
{
return imageComponentId_;
}

269
ecs/src/model/CreateImagePipelineRequest.cc Normal file
View File

@@ -0,0 +1,269 @@
/*
* 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/ecs/model/CreateImagePipelineRequest.h>
using AlibabaCloud::Ecs::Model::CreateImagePipelineRequest;
CreateImagePipelineRequest::CreateImagePipelineRequest() :
RpcServiceRequest("ecs", "2014-05-26", "CreateImagePipeline")
{
setMethod(HttpRequest::Method::Post);
}
CreateImagePipelineRequest::~CreateImagePipelineRequest()
{}
std::string CreateImagePipelineRequest::getBaseImageType()const
{
return baseImageType_;
}
void CreateImagePipelineRequest::setBaseImageType(const std::string& baseImageType)
{
baseImageType_ = baseImageType;
setParameter("BaseImageType", baseImageType);
}
long CreateImagePipelineRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateImagePipelineRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateImagePipelineRequest::getClientToken()const
{
return clientToken_;
}
void CreateImagePipelineRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::vector<std::string> CreateImagePipelineRequest::getToRegionId()const
{
return toRegionId_;
}
void CreateImagePipelineRequest::setToRegionId(const std::vector<std::string>& toRegionId)
{
toRegionId_ = toRegionId;
for(int dep1 = 0; dep1!= toRegionId.size(); dep1++) {
setParameter("ToRegionId."+ std::to_string(dep1), toRegionId.at(dep1));
}
}
int CreateImagePipelineRequest::getInternetMaxBandwidthOut()const
{
return internetMaxBandwidthOut_;
}
void CreateImagePipelineRequest::setInternetMaxBandwidthOut(int internetMaxBandwidthOut)
{
internetMaxBandwidthOut_ = internetMaxBandwidthOut;
setParameter("InternetMaxBandwidthOut", std::to_string(internetMaxBandwidthOut));
}
std::string CreateImagePipelineRequest::getDescription()const
{
return description_;
}
void CreateImagePipelineRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string CreateImagePipelineRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void CreateImagePipelineRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string CreateImagePipelineRequest::getRegionId()const
{
return regionId_;
}
void CreateImagePipelineRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateImagePipelineRequest::getImageName()const
{
return imageName_;
}
void CreateImagePipelineRequest::setImageName(const std::string& imageName)
{
imageName_ = imageName;
setParameter("ImageName", imageName);
}
int CreateImagePipelineRequest::getSystemDiskSize()const
{
return systemDiskSize_;
}
void CreateImagePipelineRequest::setSystemDiskSize(int systemDiskSize)
{
systemDiskSize_ = systemDiskSize;
setParameter("SystemDiskSize", std::to_string(systemDiskSize));
}
std::string CreateImagePipelineRequest::getInstanceType()const
{
return instanceType_;
}
void CreateImagePipelineRequest::setInstanceType(const std::string& instanceType)
{
instanceType_ = instanceType;
setParameter("InstanceType", instanceType);
}
std::vector<CreateImagePipelineRequest::Tag> CreateImagePipelineRequest::getTag()const
{
return tag_;
}
void CreateImagePipelineRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Key", tagObj.key);
setParameter(tagObjStr + ".Value", tagObj.value);
}
}
std::string CreateImagePipelineRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateImagePipelineRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateImagePipelineRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateImagePipelineRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateImagePipelineRequest::getOwnerId()const
{
return ownerId_;
}
void CreateImagePipelineRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateImagePipelineRequest::getBaseImage()const
{
return baseImage_;
}
void CreateImagePipelineRequest::setBaseImage(const std::string& baseImage)
{
baseImage_ = baseImage;
setParameter("BaseImage", baseImage);
}
std::string CreateImagePipelineRequest::getVSwitchId()const
{
return vSwitchId_;
}
void CreateImagePipelineRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
}
std::vector<long> CreateImagePipelineRequest::getAddAccount()const
{
return addAccount_;
}
void CreateImagePipelineRequest::setAddAccount(const std::vector<long>& addAccount)
{
addAccount_ = addAccount;
for(int dep1 = 0; dep1!= addAccount.size(); dep1++) {
setParameter("AddAccount."+ std::to_string(dep1), std::to_string(addAccount.at(dep1)));
}
}
bool CreateImagePipelineRequest::getDeleteInstanceOnFailure()const
{
return deleteInstanceOnFailure_;
}
void CreateImagePipelineRequest::setDeleteInstanceOnFailure(bool deleteInstanceOnFailure)
{
deleteInstanceOnFailure_ = deleteInstanceOnFailure;
setParameter("DeleteInstanceOnFailure", deleteInstanceOnFailure ? "true" : "false");
}
std::string CreateImagePipelineRequest::getName()const
{
return name_;
}
void CreateImagePipelineRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
std::string CreateImagePipelineRequest::getBuildContent()const
{
return buildContent_;
}
void CreateImagePipelineRequest::setBuildContent(const std::string& buildContent)
{
buildContent_ = buildContent;
setParameter("BuildContent", buildContent);
}

51
ecs/src/model/CreateImagePipelineResult.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/ecs/model/CreateImagePipelineResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
CreateImagePipelineResult::CreateImagePipelineResult() :
ServiceResult()
{}
CreateImagePipelineResult::CreateImagePipelineResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateImagePipelineResult::~CreateImagePipelineResult()
{}
void CreateImagePipelineResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ImagePipelineId"].isNull())
imagePipelineId_ = value["ImagePipelineId"].asString();
}
std::string CreateImagePipelineResult::getImagePipelineId()const
{
return imagePipelineId_;
}

152
ecs/src/model/CreateSnapshotGroupRequest.cc Normal file
View File

@@ -0,0 +1,152 @@
/*
* 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/ecs/model/CreateSnapshotGroupRequest.h>
using AlibabaCloud::Ecs::Model::CreateSnapshotGroupRequest;
CreateSnapshotGroupRequest::CreateSnapshotGroupRequest() :
RpcServiceRequest("ecs", "2014-05-26", "CreateSnapshotGroup")
{
setMethod(HttpRequest::Method::Post);
}
CreateSnapshotGroupRequest::~CreateSnapshotGroupRequest()
{}
long CreateSnapshotGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateSnapshotGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<std::string> CreateSnapshotGroupRequest::getExcludeDiskId()const
{
return excludeDiskId_;
}
void CreateSnapshotGroupRequest::setExcludeDiskId(const std::vector<std::string>& excludeDiskId)
{
excludeDiskId_ = excludeDiskId;
for(int dep1 = 0; dep1!= excludeDiskId.size(); dep1++) {
setParameter("ExcludeDiskId."+ std::to_string(dep1), excludeDiskId.at(dep1));
}
}
bool CreateSnapshotGroupRequest::getInstantAccess()const
{
return instantAccess_;
}
void CreateSnapshotGroupRequest::setInstantAccess(bool instantAccess)
{
instantAccess_ = instantAccess;
setParameter("InstantAccess", instantAccess ? "true" : "false");
}
std::string CreateSnapshotGroupRequest::getDescription()const
{
return description_;
}
void CreateSnapshotGroupRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
int CreateSnapshotGroupRequest::getInstantAccessRetentionDays()const
{
return instantAccessRetentionDays_;
}
void CreateSnapshotGroupRequest::setInstantAccessRetentionDays(int instantAccessRetentionDays)
{
instantAccessRetentionDays_ = instantAccessRetentionDays;
setParameter("InstantAccessRetentionDays", std::to_string(instantAccessRetentionDays));
}
std::string CreateSnapshotGroupRequest::getRegionId()const
{
return regionId_;
}
void CreateSnapshotGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string CreateSnapshotGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateSnapshotGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateSnapshotGroupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateSnapshotGroupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long CreateSnapshotGroupRequest::getOwnerId()const
{
return ownerId_;
}
void CreateSnapshotGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateSnapshotGroupRequest::getInstanceId()const
{
return instanceId_;
}
void CreateSnapshotGroupRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setParameter("InstanceId", instanceId);
}
std::string CreateSnapshotGroupRequest::getName()const
{
return name_;
}
void CreateSnapshotGroupRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

51
ecs/src/model/CreateSnapshotGroupResult.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/ecs/model/CreateSnapshotGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
CreateSnapshotGroupResult::CreateSnapshotGroupResult() :
ServiceResult()
{}
CreateSnapshotGroupResult::CreateSnapshotGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateSnapshotGroupResult::~CreateSnapshotGroupResult()
{}
void CreateSnapshotGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["SnapshotGroupId"].isNull())
snapshotGroupId_ = value["SnapshotGroupId"].asString();
}
std::string CreateSnapshotGroupResult::getSnapshotGroupId()const
{
return snapshotGroupId_;
}

95
ecs/src/model/DeleteActivationRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/ecs/model/DeleteActivationRequest.h>
using AlibabaCloud::Ecs::Model::DeleteActivationRequest;
DeleteActivationRequest::DeleteActivationRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DeleteActivation")
{
setMethod(HttpRequest::Method::Post);
}
DeleteActivationRequest::~DeleteActivationRequest()
{}
long DeleteActivationRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteActivationRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteActivationRequest::getRegionId()const
{
return regionId_;
}
void DeleteActivationRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteActivationRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteActivationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteActivationRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteActivationRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeleteActivationRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteActivationRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeleteActivationRequest::getActivationId()const
{
return activationId_;
}
void DeleteActivationRequest::setActivationId(const std::string& activationId)
{
activationId_ = activationId;
setParameter("ActivationId", activationId);
}

68
ecs/src/model/DeleteActivationResult.cc Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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/ecs/model/DeleteActivationResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DeleteActivationResult::DeleteActivationResult() :
ServiceResult()
{}
DeleteActivationResult::DeleteActivationResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteActivationResult::~DeleteActivationResult()
{}
void DeleteActivationResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto activationNode = value["Activation"];
if(!activationNode["ActivationId"].isNull())
activation_.activationId = activationNode["ActivationId"].asString();
if(!activationNode["InstanceName"].isNull())
activation_.instanceName = activationNode["InstanceName"].asString();
if(!activationNode["Description"].isNull())
activation_.description = activationNode["Description"].asString();
if(!activationNode["InstanceCount"].isNull())
activation_.instanceCount = std::stoi(activationNode["InstanceCount"].asString());
if(!activationNode["TimeToLiveInHours"].isNull())
activation_.timeToLiveInHours = std::stol(activationNode["TimeToLiveInHours"].asString());
if(!activationNode["IpAddressRange"].isNull())
activation_.ipAddressRange = activationNode["IpAddressRange"].asString();
if(!activationNode["RegisteredCount"].isNull())
activation_.registeredCount = std::stoi(activationNode["RegisteredCount"].asString());
if(!activationNode["DeregisteredCount"].isNull())
activation_.deregisteredCount = std::stoi(activationNode["DeregisteredCount"].asString());
if(!activationNode["CreationTime"].isNull())
activation_.creationTime = activationNode["CreationTime"].asString();
}
DeleteActivationResult::Activation DeleteActivationResult::getActivation()const
{
return activation_;
}

111
ecs/src/model/DeleteImageComponentRequest.cc Normal file
View File

@@ -0,0 +1,111 @@
/*
* 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/ecs/model/DeleteImageComponentRequest.h>
using AlibabaCloud::Ecs::Model::DeleteImageComponentRequest;
DeleteImageComponentRequest::DeleteImageComponentRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DeleteImageComponent")
{
setMethod(HttpRequest::Method::Post);
}
DeleteImageComponentRequest::~DeleteImageComponentRequest()
{}
long DeleteImageComponentRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteImageComponentRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteImageComponentRequest::getImageComponentId()const
{
return imageComponentId_;
}
void DeleteImageComponentRequest::setImageComponentId(const std::string& imageComponentId)
{
imageComponentId_ = imageComponentId;
setParameter("ImageComponentId", imageComponentId);
}
std::string DeleteImageComponentRequest::getRegionId()const
{
return regionId_;
}
void DeleteImageComponentRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<DeleteImageComponentRequest::TemplateTag> DeleteImageComponentRequest::getTemplateTag()const
{
return templateTag_;
}
void DeleteImageComponentRequest::setTemplateTag(const std::vector<TemplateTag>& templateTag)
{
templateTag_ = templateTag;
for(int dep1 = 0; dep1!= templateTag.size(); dep1++) {
auto templateTagObj = templateTag.at(dep1);
std::string templateTagObjStr = "TemplateTag." + std::to_string(dep1 + 1);
setParameter(templateTagObjStr + ".Key", templateTagObj.key);
setParameter(templateTagObjStr + ".Value", templateTagObj.value);
}
}
std::string DeleteImageComponentRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteImageComponentRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteImageComponentRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteImageComponentRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeleteImageComponentRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteImageComponentRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

44
ecs/src/model/DeleteImageComponentResult.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/ecs/model/DeleteImageComponentResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DeleteImageComponentResult::DeleteImageComponentResult() :
ServiceResult()
{}
DeleteImageComponentResult::DeleteImageComponentResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteImageComponentResult::~DeleteImageComponentResult()
{}
void DeleteImageComponentResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

111
ecs/src/model/DeleteImagePipelineRequest.cc Normal file
View File

@@ -0,0 +1,111 @@
/*
* 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/ecs/model/DeleteImagePipelineRequest.h>
using AlibabaCloud::Ecs::Model::DeleteImagePipelineRequest;
DeleteImagePipelineRequest::DeleteImagePipelineRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DeleteImagePipeline")
{
setMethod(HttpRequest::Method::Post);
}
DeleteImagePipelineRequest::~DeleteImagePipelineRequest()
{}
std::string DeleteImagePipelineRequest::getImagePipelineId()const
{
return imagePipelineId_;
}
void DeleteImagePipelineRequest::setImagePipelineId(const std::string& imagePipelineId)
{
imagePipelineId_ = imagePipelineId;
setParameter("ImagePipelineId", imagePipelineId);
}
long DeleteImagePipelineRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteImagePipelineRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteImagePipelineRequest::getRegionId()const
{
return regionId_;
}
void DeleteImagePipelineRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<DeleteImagePipelineRequest::TemplateTag> DeleteImagePipelineRequest::getTemplateTag()const
{
return templateTag_;
}
void DeleteImagePipelineRequest::setTemplateTag(const std::vector<TemplateTag>& templateTag)
{
templateTag_ = templateTag;
for(int dep1 = 0; dep1!= templateTag.size(); dep1++) {
auto templateTagObj = templateTag.at(dep1);
std::string templateTagObjStr = "TemplateTag." + std::to_string(dep1 + 1);
setParameter(templateTagObjStr + ".Key", templateTagObj.key);
setParameter(templateTagObjStr + ".Value", templateTagObj.value);
}
}
std::string DeleteImagePipelineRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteImagePipelineRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteImagePipelineRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteImagePipelineRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeleteImagePipelineRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteImagePipelineRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

44
ecs/src/model/DeleteImagePipelineResult.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/ecs/model/DeleteImagePipelineResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DeleteImagePipelineResult::DeleteImagePipelineResult() :
ServiceResult()
{}
DeleteImagePipelineResult::DeleteImagePipelineResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteImagePipelineResult::~DeleteImagePipelineResult()
{}
void DeleteImagePipelineResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

95
ecs/src/model/DeleteSnapshotGroupRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/ecs/model/DeleteSnapshotGroupRequest.h>
using AlibabaCloud::Ecs::Model::DeleteSnapshotGroupRequest;
DeleteSnapshotGroupRequest::DeleteSnapshotGroupRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DeleteSnapshotGroup")
{
setMethod(HttpRequest::Method::Post);
}
DeleteSnapshotGroupRequest::~DeleteSnapshotGroupRequest()
{}
long DeleteSnapshotGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteSnapshotGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteSnapshotGroupRequest::getRegionId()const
{
return regionId_;
}
void DeleteSnapshotGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeleteSnapshotGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteSnapshotGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteSnapshotGroupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteSnapshotGroupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DeleteSnapshotGroupRequest::getSnapshotGroupId()const
{
return snapshotGroupId_;
}
void DeleteSnapshotGroupRequest::setSnapshotGroupId(const std::string& snapshotGroupId)
{
snapshotGroupId_ = snapshotGroupId;
setParameter("SnapshotGroupId", snapshotGroupId);
}
long DeleteSnapshotGroupRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteSnapshotGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

71
ecs/src/model/DeleteSnapshotGroupResult.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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/ecs/model/DeleteSnapshotGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DeleteSnapshotGroupResult::DeleteSnapshotGroupResult() :
ServiceResult()
{}
DeleteSnapshotGroupResult::DeleteSnapshotGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteSnapshotGroupResult::~DeleteSnapshotGroupResult()
{}
void DeleteSnapshotGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allOperationProgressSetNode = value["OperationProgressSet"]["OperationProgress"];
for (auto valueOperationProgressSetOperationProgress : allOperationProgressSetNode)
{
OperationProgress operationProgressSetObject;
if(!valueOperationProgressSetOperationProgress["OperationStatus"].isNull())
operationProgressSetObject.operationStatus = valueOperationProgressSetOperationProgress["OperationStatus"].asString();
if(!valueOperationProgressSetOperationProgress["ErrorCode"].isNull())
operationProgressSetObject.errorCode = valueOperationProgressSetOperationProgress["ErrorCode"].asString();
if(!valueOperationProgressSetOperationProgress["ErrorMsg"].isNull())
operationProgressSetObject.errorMsg = valueOperationProgressSetOperationProgress["ErrorMsg"].asString();
auto allRelatedItemSetNode = valueOperationProgressSetOperationProgress["RelatedItemSet"]["RelatedItem"];
for (auto valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem : allRelatedItemSetNode)
{
OperationProgress::RelatedItem relatedItemSetObject;
if(!valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem["Name"].isNull())
relatedItemSetObject.name = valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem["Name"].asString();
if(!valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem["Value"].isNull())
relatedItemSetObject.value = valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem["Value"].asString();
operationProgressSetObject.relatedItemSet.push_back(relatedItemSetObject);
}
operationProgressSet_.push_back(operationProgressSetObject);
}
}
std::vector<DeleteSnapshotGroupResult::OperationProgress> DeleteSnapshotGroupResult::getOperationProgressSet()const
{
return operationProgressSet_;
}

95
ecs/src/model/DeregisterManagedInstanceRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/ecs/model/DeregisterManagedInstanceRequest.h>
using AlibabaCloud::Ecs::Model::DeregisterManagedInstanceRequest;
DeregisterManagedInstanceRequest::DeregisterManagedInstanceRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DeregisterManagedInstance")
{
setMethod(HttpRequest::Method::Post);
}
DeregisterManagedInstanceRequest::~DeregisterManagedInstanceRequest()
{}
long DeregisterManagedInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeregisterManagedInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeregisterManagedInstanceRequest::getRegionId()const
{
return regionId_;
}
void DeregisterManagedInstanceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DeregisterManagedInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeregisterManagedInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeregisterManagedInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeregisterManagedInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeregisterManagedInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void DeregisterManagedInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DeregisterManagedInstanceRequest::getInstanceId()const
{
return instanceId_;
}
void DeregisterManagedInstanceRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setParameter("InstanceId", instanceId);
}

76
ecs/src/model/DeregisterManagedInstanceResult.cc Normal file
View File

@@ -0,0 +1,76 @@
/*
* 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/ecs/model/DeregisterManagedInstanceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DeregisterManagedInstanceResult::DeregisterManagedInstanceResult() :
ServiceResult()
{}
DeregisterManagedInstanceResult::DeregisterManagedInstanceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeregisterManagedInstanceResult::~DeregisterManagedInstanceResult()
{}
void DeregisterManagedInstanceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto instanceNode = value["Instance"];
if(!instanceNode["InstanceId"].isNull())
instance_.instanceId = instanceNode["InstanceId"].asString();
if(!instanceNode["InstanceName"].isNull())
instance_.instanceName = instanceNode["InstanceName"].asString();
if(!instanceNode["ActivationId"].isNull())
instance_.activationId = instanceNode["ActivationId"].asString();
if(!instanceNode["Hostname"].isNull())
instance_.hostname = instanceNode["Hostname"].asString();
if(!instanceNode["MachineId"].isNull())
instance_.machineId = instanceNode["MachineId"].asString();
if(!instanceNode["OsType"].isNull())
instance_.osType = instanceNode["OsType"].asString();
if(!instanceNode["OsVersion"].isNull())
instance_.osVersion = instanceNode["OsVersion"].asString();
if(!instanceNode["IntranetIp"].isNull())
instance_.intranetIp = instanceNode["IntranetIp"].asString();
if(!instanceNode["InternetIp"].isNull())
instance_.internetIp = instanceNode["InternetIp"].asString();
if(!instanceNode["AgentVersion"].isNull())
instance_.agentVersion = instanceNode["AgentVersion"].asString();
if(!instanceNode["RegistrationTime"].isNull())
instance_.registrationTime = instanceNode["RegistrationTime"].asString();
if(!instanceNode["InvocationCount"].isNull())
instance_.invocationCount = std::stol(instanceNode["InvocationCount"].asString());
if(!instanceNode["LastInvokedTime"].isNull())
instance_.lastInvokedTime = instanceNode["LastInvokedTime"].asString();
}
DeregisterManagedInstanceResult::Instance DeregisterManagedInstanceResult::getInstance()const
{
return instance_;
}

128
ecs/src/model/DescribeActivationsRequest.cc Normal file
View File

@@ -0,0 +1,128 @@
/*
* 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/ecs/model/DescribeActivationsRequest.h>
using AlibabaCloud::Ecs::Model::DescribeActivationsRequest;
DescribeActivationsRequest::DescribeActivationsRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DescribeActivations")
{
setMethod(HttpRequest::Method::Post);
}
DescribeActivationsRequest::~DescribeActivationsRequest()
{}
long DescribeActivationsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeActivationsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
long DescribeActivationsRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeActivationsRequest::setPageNumber(long pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeActivationsRequest::getRegionId()const
{
return regionId_;
}
void DescribeActivationsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
long DescribeActivationsRequest::getPageSize()const
{
return pageSize_;
}
void DescribeActivationsRequest::setPageSize(long pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeActivationsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeActivationsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeActivationsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeActivationsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeActivationsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeActivationsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeActivationsRequest::getInstanceName()const
{
return instanceName_;
}
void DescribeActivationsRequest::setInstanceName(const std::string& instanceName)
{
instanceName_ = instanceName;
setParameter("InstanceName", instanceName);
}
std::string DescribeActivationsRequest::getActivationId()const
{
return activationId_;
}
void DescribeActivationsRequest::setActivationId(const std::string& activationId)
{
activationId_ = activationId;
setParameter("ActivationId", activationId);
}

96
ecs/src/model/DescribeActivationsResult.cc Normal file
View File

@@ -0,0 +1,96 @@
/*
* 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/ecs/model/DescribeActivationsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeActivationsResult::DescribeActivationsResult() :
ServiceResult()
{}
DescribeActivationsResult::DescribeActivationsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeActivationsResult::~DescribeActivationsResult()
{}
void DescribeActivationsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allActivationListNode = value["ActivationList"]["Activation"];
for (auto valueActivationListActivation : allActivationListNode)
{
Activation activationListObject;
if(!valueActivationListActivation["ActivationId"].isNull())
activationListObject.activationId = valueActivationListActivation["ActivationId"].asString();
if(!valueActivationListActivation["InstanceName"].isNull())
activationListObject.instanceName = valueActivationListActivation["InstanceName"].asString();
if(!valueActivationListActivation["Description"].isNull())
activationListObject.description = valueActivationListActivation["Description"].asString();
if(!valueActivationListActivation["InstanceCount"].isNull())
activationListObject.instanceCount = std::stoi(valueActivationListActivation["InstanceCount"].asString());
if(!valueActivationListActivation["TimeToLiveInHours"].isNull())
activationListObject.timeToLiveInHours = std::stol(valueActivationListActivation["TimeToLiveInHours"].asString());
if(!valueActivationListActivation["IpAddressRange"].isNull())
activationListObject.ipAddressRange = valueActivationListActivation["IpAddressRange"].asString();
if(!valueActivationListActivation["RegisteredCount"].isNull())
activationListObject.registeredCount = std::stoi(valueActivationListActivation["RegisteredCount"].asString());
if(!valueActivationListActivation["DeregisteredCount"].isNull())
activationListObject.deregisteredCount = std::stoi(valueActivationListActivation["DeregisteredCount"].asString());
if(!valueActivationListActivation["Disabled"].isNull())
activationListObject.disabled = valueActivationListActivation["Disabled"].asString() == "true";
if(!valueActivationListActivation["CreationTime"].isNull())
activationListObject.creationTime = valueActivationListActivation["CreationTime"].asString();
activationList_.push_back(activationListObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stol(value["TotalCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stol(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stol(value["PageSize"].asString());
}
long DescribeActivationsResult::getTotalCount()const
{
return totalCount_;
}
long DescribeActivationsResult::getPageSize()const
{
return pageSize_;
}
long DescribeActivationsResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeActivationsResult::Activation> DescribeActivationsResult::getActivationList()const
{
return activationList_;
}

11
ecs/src/model/DescribeCommandsRequest.cc
View File

@@ -93,6 +93,17 @@ void DescribeCommandsRequest::setRegionId(const std::string& regionId)
setParameter("RegionId", regionId);
}
std::string DescribeCommandsRequest::getProvider()const
{
return provider_;
}
void DescribeCommandsRequest::setProvider(const std::string& provider)
{
provider_ = provider;
setParameter("Provider", provider);
}
std::string DescribeCommandsRequest::getContentEncoding()const
{
return contentEncoding_;

8
ecs/src/model/DescribeCommandsResult.cc
View File

@@ -49,6 +49,14 @@ void DescribeCommandsResult::parse(const std::string &payload)
commandsObject.name = valueCommandsCommand["Name"].asString();
if(!valueCommandsCommand["Type"].isNull())
commandsObject.type = valueCommandsCommand["Type"].asString();
if(!valueCommandsCommand["Version"].isNull())
commandsObject.version = std::stoi(valueCommandsCommand["Version"].asString());
if(!valueCommandsCommand["Latest"].isNull())
commandsObject.latest = valueCommandsCommand["Latest"].asString() == "true";
if(!valueCommandsCommand["Provider"].isNull())
commandsObject.provider = valueCommandsCommand["Provider"].asString();
if(!valueCommandsCommand["Category"].isNull())
commandsObject.category = valueCommandsCommand["Category"].asString();
if(!valueCommandsCommand["Description"].isNull())
commandsObject.description = valueCommandsCommand["Description"].asString();
if(!valueCommandsCommand["CommandContent"].isNull())

157
ecs/src/model/DescribeImageComponentsRequest.cc Normal file
View File

@@ -0,0 +1,157 @@
/*
* 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/ecs/model/DescribeImageComponentsRequest.h>
using AlibabaCloud::Ecs::Model::DescribeImageComponentsRequest;
DescribeImageComponentsRequest::DescribeImageComponentsRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DescribeImageComponents")
{
setMethod(HttpRequest::Method::Post);
}
DescribeImageComponentsRequest::~DescribeImageComponentsRequest()
{}
long DescribeImageComponentsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeImageComponentsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::vector<std::string> DescribeImageComponentsRequest::getImageComponentId()const
{
return imageComponentId_;
}
void DescribeImageComponentsRequest::setImageComponentId(const std::vector<std::string>& imageComponentId)
{
imageComponentId_ = imageComponentId;
for(int dep1 = 0; dep1!= imageComponentId.size(); dep1++) {
setParameter("ImageComponentId."+ std::to_string(dep1), imageComponentId.at(dep1));
}
}
std::string DescribeImageComponentsRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void DescribeImageComponentsRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string DescribeImageComponentsRequest::getRegionId()const
{
return regionId_;
}
void DescribeImageComponentsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeImageComponentsRequest::getNextToken()const
{
return nextToken_;
}
void DescribeImageComponentsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::vector<DescribeImageComponentsRequest::Tag> DescribeImageComponentsRequest::getTag()const
{
return tag_;
}
void DescribeImageComponentsRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Key", tagObj.key);
setParameter(tagObjStr + ".Value", tagObj.value);
}
}
std::string DescribeImageComponentsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeImageComponentsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeImageComponentsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeImageComponentsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeImageComponentsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeImageComponentsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeImageComponentsRequest::getName()const
{
return name_;
}
void DescribeImageComponentsRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
int DescribeImageComponentsRequest::getMaxResults()const
{
return maxResults_;
}
void DescribeImageComponentsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}

102
ecs/src/model/DescribeImageComponentsResult.cc Normal file
View File

@@ -0,0 +1,102 @@
/*
* 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/ecs/model/DescribeImageComponentsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeImageComponentsResult::DescribeImageComponentsResult() :
ServiceResult()
{}
DescribeImageComponentsResult::DescribeImageComponentsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeImageComponentsResult::~DescribeImageComponentsResult()
{}
void DescribeImageComponentsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allImageComponentNode = value["ImageComponent"]["ImageComponentSet"];
for (auto valueImageComponentImageComponentSet : allImageComponentNode)
{
ImageComponentSet imageComponentObject;
if(!valueImageComponentImageComponentSet["CreationTime"].isNull())
imageComponentObject.creationTime = valueImageComponentImageComponentSet["CreationTime"].asString();
if(!valueImageComponentImageComponentSet["ImageComponentId"].isNull())
imageComponentObject.imageComponentId = valueImageComponentImageComponentSet["ImageComponentId"].asString();
if(!valueImageComponentImageComponentSet["Name"].isNull())
imageComponentObject.name = valueImageComponentImageComponentSet["Name"].asString();
if(!valueImageComponentImageComponentSet["Description"].isNull())
imageComponentObject.description = valueImageComponentImageComponentSet["Description"].asString();
if(!valueImageComponentImageComponentSet["SystemType"].isNull())
imageComponentObject.systemType = valueImageComponentImageComponentSet["SystemType"].asString();
if(!valueImageComponentImageComponentSet["ComponentType"].isNull())
imageComponentObject.componentType = valueImageComponentImageComponentSet["ComponentType"].asString();
if(!valueImageComponentImageComponentSet["Content"].isNull())
imageComponentObject.content = valueImageComponentImageComponentSet["Content"].asString();
if(!valueImageComponentImageComponentSet["ResourceGroupId"].isNull())
imageComponentObject.resourceGroupId = valueImageComponentImageComponentSet["ResourceGroupId"].asString();
auto allTagsNode = valueImageComponentImageComponentSet["Tags"]["Tag"];
for (auto valueImageComponentImageComponentSetTagsTag : allTagsNode)
{
ImageComponentSet::Tag tagsObject;
if(!valueImageComponentImageComponentSetTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueImageComponentImageComponentSetTagsTag["TagKey"].asString();
if(!valueImageComponentImageComponentSetTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueImageComponentImageComponentSetTagsTag["TagValue"].asString();
imageComponentObject.tags.push_back(tagsObject);
}
imageComponent_.push_back(imageComponentObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
}
int DescribeImageComponentsResult::getTotalCount()const
{
return totalCount_;
}
std::vector<DescribeImageComponentsResult::ImageComponentSet> DescribeImageComponentsResult::getImageComponent()const
{
return imageComponent_;
}
std::string DescribeImageComponentsResult::getNextToken()const
{
return nextToken_;
}
int DescribeImageComponentsResult::getMaxResults()const
{
return maxResults_;
}

155
ecs/src/model/DescribeImagePipelineExecutionsRequest.cc Normal file
View File

@@ -0,0 +1,155 @@
/*
* 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/ecs/model/DescribeImagePipelineExecutionsRequest.h>
using AlibabaCloud::Ecs::Model::DescribeImagePipelineExecutionsRequest;
DescribeImagePipelineExecutionsRequest::DescribeImagePipelineExecutionsRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DescribeImagePipelineExecutions")
{
setMethod(HttpRequest::Method::Post);
}
DescribeImagePipelineExecutionsRequest::~DescribeImagePipelineExecutionsRequest()
{}
std::string DescribeImagePipelineExecutionsRequest::getImagePipelineId()const
{
return imagePipelineId_;
}
void DescribeImagePipelineExecutionsRequest::setImagePipelineId(const std::string& imagePipelineId)
{
imagePipelineId_ = imagePipelineId;
setParameter("ImagePipelineId", imagePipelineId);
}
long DescribeImagePipelineExecutionsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeImagePipelineExecutionsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeImagePipelineExecutionsRequest::getExecutionId()const
{
return executionId_;
}
void DescribeImagePipelineExecutionsRequest::setExecutionId(const std::string& executionId)
{
executionId_ = executionId;
setParameter("ExecutionId", executionId);
}
std::string DescribeImagePipelineExecutionsRequest::getRegionId()const
{
return regionId_;
}
void DescribeImagePipelineExecutionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeImagePipelineExecutionsRequest::getNextToken()const
{
return nextToken_;
}
void DescribeImagePipelineExecutionsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::vector<DescribeImagePipelineExecutionsRequest::Tag> DescribeImagePipelineExecutionsRequest::getTag()const
{
return tag_;
}
void DescribeImagePipelineExecutionsRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Key", tagObj.key);
setParameter(tagObjStr + ".Value", tagObj.value);
}
}
std::string DescribeImagePipelineExecutionsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeImagePipelineExecutionsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeImagePipelineExecutionsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeImagePipelineExecutionsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeImagePipelineExecutionsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeImagePipelineExecutionsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
int DescribeImagePipelineExecutionsRequest::getMaxResults()const
{
return maxResults_;
}
void DescribeImagePipelineExecutionsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::string DescribeImagePipelineExecutionsRequest::getStatus()const
{
return status_;
}
void DescribeImagePipelineExecutionsRequest::setStatus(const std::string& status)
{
status_ = status;
setParameter("Status", status);
}

102
ecs/src/model/DescribeImagePipelineExecutionsResult.cc Normal file
View File

@@ -0,0 +1,102 @@
/*
* 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/ecs/model/DescribeImagePipelineExecutionsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeImagePipelineExecutionsResult::DescribeImagePipelineExecutionsResult() :
ServiceResult()
{}
DescribeImagePipelineExecutionsResult::DescribeImagePipelineExecutionsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeImagePipelineExecutionsResult::~DescribeImagePipelineExecutionsResult()
{}
void DescribeImagePipelineExecutionsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allImagePipelineExecutionNode = value["ImagePipelineExecution"]["ImagePipelineExecutionSet"];
for (auto valueImagePipelineExecutionImagePipelineExecutionSet : allImagePipelineExecutionNode)
{
ImagePipelineExecutionSet imagePipelineExecutionObject;
if(!valueImagePipelineExecutionImagePipelineExecutionSet["CreationTime"].isNull())
imagePipelineExecutionObject.creationTime = valueImagePipelineExecutionImagePipelineExecutionSet["CreationTime"].asString();
if(!valueImagePipelineExecutionImagePipelineExecutionSet["ModifiedTime"].isNull())
imagePipelineExecutionObject.modifiedTime = valueImagePipelineExecutionImagePipelineExecutionSet["ModifiedTime"].asString();
if(!valueImagePipelineExecutionImagePipelineExecutionSet["ImageId"].isNull())
imagePipelineExecutionObject.imageId = valueImagePipelineExecutionImagePipelineExecutionSet["ImageId"].asString();
if(!valueImagePipelineExecutionImagePipelineExecutionSet["ImagePipelineId"].isNull())
imagePipelineExecutionObject.imagePipelineId = valueImagePipelineExecutionImagePipelineExecutionSet["ImagePipelineId"].asString();
if(!valueImagePipelineExecutionImagePipelineExecutionSet["ExecutionId"].isNull())
imagePipelineExecutionObject.executionId = valueImagePipelineExecutionImagePipelineExecutionSet["ExecutionId"].asString();
if(!valueImagePipelineExecutionImagePipelineExecutionSet["Status"].isNull())
imagePipelineExecutionObject.status = valueImagePipelineExecutionImagePipelineExecutionSet["Status"].asString();
if(!valueImagePipelineExecutionImagePipelineExecutionSet["Message"].isNull())
imagePipelineExecutionObject.message = valueImagePipelineExecutionImagePipelineExecutionSet["Message"].asString();
if(!valueImagePipelineExecutionImagePipelineExecutionSet["ResourceGroupId"].isNull())
imagePipelineExecutionObject.resourceGroupId = valueImagePipelineExecutionImagePipelineExecutionSet["ResourceGroupId"].asString();
auto allTagsNode = valueImagePipelineExecutionImagePipelineExecutionSet["Tags"]["Tag"];
for (auto valueImagePipelineExecutionImagePipelineExecutionSetTagsTag : allTagsNode)
{
ImagePipelineExecutionSet::Tag tagsObject;
if(!valueImagePipelineExecutionImagePipelineExecutionSetTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueImagePipelineExecutionImagePipelineExecutionSetTagsTag["TagKey"].asString();
if(!valueImagePipelineExecutionImagePipelineExecutionSetTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueImagePipelineExecutionImagePipelineExecutionSetTagsTag["TagValue"].asString();
imagePipelineExecutionObject.tags.push_back(tagsObject);
}
imagePipelineExecution_.push_back(imagePipelineExecutionObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
}
int DescribeImagePipelineExecutionsResult::getTotalCount()const
{
return totalCount_;
}
std::string DescribeImagePipelineExecutionsResult::getNextToken()const
{
return nextToken_;
}
int DescribeImagePipelineExecutionsResult::getMaxResults()const
{
return maxResults_;
}
std::vector<DescribeImagePipelineExecutionsResult::ImagePipelineExecutionSet> DescribeImagePipelineExecutionsResult::getImagePipelineExecution()const
{
return imagePipelineExecution_;
}

157
ecs/src/model/DescribeImagePipelinesRequest.cc Normal file
View File

@@ -0,0 +1,157 @@
/*
* 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/ecs/model/DescribeImagePipelinesRequest.h>
using AlibabaCloud::Ecs::Model::DescribeImagePipelinesRequest;
DescribeImagePipelinesRequest::DescribeImagePipelinesRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DescribeImagePipelines")
{
setMethod(HttpRequest::Method::Post);
}
DescribeImagePipelinesRequest::~DescribeImagePipelinesRequest()
{}
std::vector<std::string> DescribeImagePipelinesRequest::getImagePipelineId()const
{
return imagePipelineId_;
}
void DescribeImagePipelinesRequest::setImagePipelineId(const std::vector<std::string>& imagePipelineId)
{
imagePipelineId_ = imagePipelineId;
for(int dep1 = 0; dep1!= imagePipelineId.size(); dep1++) {
setParameter("ImagePipelineId."+ std::to_string(dep1), imagePipelineId.at(dep1));
}
}
long DescribeImagePipelinesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeImagePipelinesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeImagePipelinesRequest::getResourceGroupId()const
{
return resourceGroupId_;
}
void DescribeImagePipelinesRequest::setResourceGroupId(const std::string& resourceGroupId)
{
resourceGroupId_ = resourceGroupId;
setParameter("ResourceGroupId", resourceGroupId);
}
std::string DescribeImagePipelinesRequest::getRegionId()const
{
return regionId_;
}
void DescribeImagePipelinesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeImagePipelinesRequest::getNextToken()const
{
return nextToken_;
}
void DescribeImagePipelinesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::vector<DescribeImagePipelinesRequest::Tag> DescribeImagePipelinesRequest::getTag()const
{
return tag_;
}
void DescribeImagePipelinesRequest::setTag(const std::vector<Tag>& tag)
{
tag_ = tag;
for(int dep1 = 0; dep1!= tag.size(); dep1++) {
auto tagObj = tag.at(dep1);
std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
setParameter(tagObjStr + ".Key", tagObj.key);
setParameter(tagObjStr + ".Value", tagObj.value);
}
}
std::string DescribeImagePipelinesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeImagePipelinesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeImagePipelinesRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeImagePipelinesRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeImagePipelinesRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeImagePipelinesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeImagePipelinesRequest::getName()const
{
return name_;
}
void DescribeImagePipelinesRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
int DescribeImagePipelinesRequest::getMaxResults()const
{
return maxResults_;
}
void DescribeImagePipelinesRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}

120
ecs/src/model/DescribeImagePipelinesResult.cc Normal file
View File

@@ -0,0 +1,120 @@
/*
* 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/ecs/model/DescribeImagePipelinesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeImagePipelinesResult::DescribeImagePipelinesResult() :
ServiceResult()
{}
DescribeImagePipelinesResult::DescribeImagePipelinesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeImagePipelinesResult::~DescribeImagePipelinesResult()
{}
void DescribeImagePipelinesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allImagePipelineNode = value["ImagePipeline"]["ImagePipelineSet"];
for (auto valueImagePipelineImagePipelineSet : allImagePipelineNode)
{
ImagePipelineSet imagePipelineObject;
if(!valueImagePipelineImagePipelineSet["CreationTime"].isNull())
imagePipelineObject.creationTime = valueImagePipelineImagePipelineSet["CreationTime"].asString();
if(!valueImagePipelineImagePipelineSet["ImagePipelineId"].isNull())
imagePipelineObject.imagePipelineId = valueImagePipelineImagePipelineSet["ImagePipelineId"].asString();
if(!valueImagePipelineImagePipelineSet["Name"].isNull())
imagePipelineObject.name = valueImagePipelineImagePipelineSet["Name"].asString();
if(!valueImagePipelineImagePipelineSet["Description"].isNull())
imagePipelineObject.description = valueImagePipelineImagePipelineSet["Description"].asString();
if(!valueImagePipelineImagePipelineSet["BaseImageType"].isNull())
imagePipelineObject.baseImageType = valueImagePipelineImagePipelineSet["BaseImageType"].asString();
if(!valueImagePipelineImagePipelineSet["BaseImage"].isNull())
imagePipelineObject.baseImage = valueImagePipelineImagePipelineSet["BaseImage"].asString();
if(!valueImagePipelineImagePipelineSet["ImageName"].isNull())
imagePipelineObject.imageName = valueImagePipelineImagePipelineSet["ImageName"].asString();
if(!valueImagePipelineImagePipelineSet["VSwitchId"].isNull())
imagePipelineObject.vSwitchId = valueImagePipelineImagePipelineSet["VSwitchId"].asString();
if(!valueImagePipelineImagePipelineSet["InstanceType"].isNull())
imagePipelineObject.instanceType = valueImagePipelineImagePipelineSet["InstanceType"].asString();
if(!valueImagePipelineImagePipelineSet["InternetMaxBandwidthOut"].isNull())
imagePipelineObject.internetMaxBandwidthOut = std::stoi(valueImagePipelineImagePipelineSet["InternetMaxBandwidthOut"].asString());
if(!valueImagePipelineImagePipelineSet["SystemDiskSize"].isNull())
imagePipelineObject.systemDiskSize = std::stoi(valueImagePipelineImagePipelineSet["SystemDiskSize"].asString());
if(!valueImagePipelineImagePipelineSet["DeleteInstanceOnFailure"].isNull())
imagePipelineObject.deleteInstanceOnFailure = valueImagePipelineImagePipelineSet["DeleteInstanceOnFailure"].asString() == "true";
if(!valueImagePipelineImagePipelineSet["BuildContent"].isNull())
imagePipelineObject.buildContent = valueImagePipelineImagePipelineSet["BuildContent"].asString();
if(!valueImagePipelineImagePipelineSet["ResourceGroupId"].isNull())
imagePipelineObject.resourceGroupId = valueImagePipelineImagePipelineSet["ResourceGroupId"].asString();
auto allTagsNode = valueImagePipelineImagePipelineSet["Tags"]["Tag"];
for (auto valueImagePipelineImagePipelineSetTagsTag : allTagsNode)
{
ImagePipelineSet::Tag tagsObject;
if(!valueImagePipelineImagePipelineSetTagsTag["TagKey"].isNull())
tagsObject.tagKey = valueImagePipelineImagePipelineSetTagsTag["TagKey"].asString();
if(!valueImagePipelineImagePipelineSetTagsTag["TagValue"].isNull())
tagsObject.tagValue = valueImagePipelineImagePipelineSetTagsTag["TagValue"].asString();
imagePipelineObject.tags.push_back(tagsObject);
}
auto allAddAccounts = value["AddAccounts"]["AddAccount"];
for (auto value : allAddAccounts)
imagePipelineObject.addAccounts.push_back(value.asString());
auto allToRegionIds = value["ToRegionIds"]["ToRegionId"];
for (auto value : allToRegionIds)
imagePipelineObject.toRegionIds.push_back(value.asString());
imagePipeline_.push_back(imagePipelineObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stoi(value["TotalCount"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = std::stoi(value["MaxResults"].asString());
}
int DescribeImagePipelinesResult::getTotalCount()const
{
return totalCount_;
}
std::string DescribeImagePipelinesResult::getNextToken()const
{
return nextToken_;
}
int DescribeImagePipelinesResult::getMaxResults()const
{
return maxResults_;
}
std::vector<DescribeImagePipelinesResult::ImagePipelineSet> DescribeImagePipelinesResult::getImagePipeline()const
{
return imagePipeline_;
}

22
ecs/src/model/DescribeInstancesRequest.cc
View File

@@ -287,6 +287,17 @@ void DescribeInstancesRequest::setZoneId(const std::string& zoneId)
setParameter("ZoneId", zoneId);
}
int DescribeInstancesRequest::getMaxResults()const
{
return maxResults_;
}
void DescribeInstancesRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::string DescribeInstancesRequest::getInstanceNetworkType()const
{
return instanceNetworkType_;
@@ -386,6 +397,17 @@ void DescribeInstancesRequest::setRegionId(const std::string& regionId)
setParameter("RegionId", regionId);
}
std::string DescribeInstancesRequest::getNextToken()const
{
return nextToken_;
}
void DescribeInstancesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::string DescribeInstancesRequest::getRdmaIpAddresses()const
{
return rdmaIpAddresses_;

7
ecs/src/model/DescribeInstancesResult.cc
View File

@@ -261,6 +261,8 @@ void DescribeInstancesResult::parse(const std::string &payload)
pageNumber_ = std::stoi(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stoi(value["PageSize"].asString());
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
@@ -279,6 +281,11 @@ int DescribeInstancesResult::getPageSize()const
return pageSize_;
}
std::string DescribeInstancesResult::getNextToken()const
{
return nextToken_;
}
int DescribeInstancesResult::getPageNumber()const
{
return pageNumber_;

163
ecs/src/model/DescribeManagedInstancesRequest.cc Normal file
View File

@@ -0,0 +1,163 @@
/*
* 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/ecs/model/DescribeManagedInstancesRequest.h>
using AlibabaCloud::Ecs::Model::DescribeManagedInstancesRequest;
DescribeManagedInstancesRequest::DescribeManagedInstancesRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DescribeManagedInstances")
{
setMethod(HttpRequest::Method::Post);
}
DescribeManagedInstancesRequest::~DescribeManagedInstancesRequest()
{}
long DescribeManagedInstancesRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeManagedInstancesRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
long DescribeManagedInstancesRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeManagedInstancesRequest::setPageNumber(long pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeManagedInstancesRequest::getRegionId()const
{
return regionId_;
}
void DescribeManagedInstancesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
long DescribeManagedInstancesRequest::getPageSize()const
{
return pageSize_;
}
void DescribeManagedInstancesRequest::setPageSize(long pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeManagedInstancesRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeManagedInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeManagedInstancesRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeManagedInstancesRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeManagedInstancesRequest::getOsType()const
{
return osType_;
}
void DescribeManagedInstancesRequest::setOsType(const std::string& osType)
{
osType_ = osType;
setParameter("OsType", osType);
}
long DescribeManagedInstancesRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeManagedInstancesRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeManagedInstancesRequest::getInstanceName()const
{
return instanceName_;
}
void DescribeManagedInstancesRequest::setInstanceName(const std::string& instanceName)
{
instanceName_ = instanceName;
setParameter("InstanceName", instanceName);
}
std::vector<std::string> DescribeManagedInstancesRequest::getInstanceId()const
{
return instanceId_;
}
void DescribeManagedInstancesRequest::setInstanceId(const std::vector<std::string>& instanceId)
{
instanceId_ = instanceId;
for(int dep1 = 0; dep1!= instanceId.size(); dep1++) {
setParameter("InstanceId."+ std::to_string(dep1), instanceId.at(dep1));
}
}
std::string DescribeManagedInstancesRequest::getInstanceIp()const
{
return instanceIp_;
}
void DescribeManagedInstancesRequest::setInstanceIp(const std::string& instanceIp)
{
instanceIp_ = instanceIp;
setParameter("InstanceIp", instanceIp);
}
std::string DescribeManagedInstancesRequest::getActivationId()const
{
return activationId_;
}
void DescribeManagedInstancesRequest::setActivationId(const std::string& activationId)
{
activationId_ = activationId;
setParameter("ActivationId", activationId);
}

104
ecs/src/model/DescribeManagedInstancesResult.cc Normal file
View File

@@ -0,0 +1,104 @@
/*
* 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/ecs/model/DescribeManagedInstancesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeManagedInstancesResult::DescribeManagedInstancesResult() :
ServiceResult()
{}
DescribeManagedInstancesResult::DescribeManagedInstancesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeManagedInstancesResult::~DescribeManagedInstancesResult()
{}
void DescribeManagedInstancesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allInstancesNode = value["Instances"]["Instance"];
for (auto valueInstancesInstance : allInstancesNode)
{
Instance instancesObject;
if(!valueInstancesInstance["InstanceId"].isNull())
instancesObject.instanceId = valueInstancesInstance["InstanceId"].asString();
if(!valueInstancesInstance["InstanceName"].isNull())
instancesObject.instanceName = valueInstancesInstance["InstanceName"].asString();
if(!valueInstancesInstance["ActivationId"].isNull())
instancesObject.activationId = valueInstancesInstance["ActivationId"].asString();
if(!valueInstancesInstance["Hostname"].isNull())
instancesObject.hostname = valueInstancesInstance["Hostname"].asString();
if(!valueInstancesInstance["MachineId"].isNull())
instancesObject.machineId = valueInstancesInstance["MachineId"].asString();
if(!valueInstancesInstance["OsType"].isNull())
instancesObject.osType = valueInstancesInstance["OsType"].asString();
if(!valueInstancesInstance["OsVersion"].isNull())
instancesObject.osVersion = valueInstancesInstance["OsVersion"].asString();
if(!valueInstancesInstance["IntranetIp"].isNull())
instancesObject.intranetIp = valueInstancesInstance["IntranetIp"].asString();
if(!valueInstancesInstance["InternetIp"].isNull())
instancesObject.internetIp = valueInstancesInstance["InternetIp"].asString();
if(!valueInstancesInstance["AgentVersion"].isNull())
instancesObject.agentVersion = valueInstancesInstance["AgentVersion"].asString();
if(!valueInstancesInstance["RegistrationTime"].isNull())
instancesObject.registrationTime = valueInstancesInstance["RegistrationTime"].asString();
if(!valueInstancesInstance["InvocationCount"].isNull())
instancesObject.invocationCount = std::stol(valueInstancesInstance["InvocationCount"].asString());
if(!valueInstancesInstance["LastInvokedTime"].isNull())
instancesObject.lastInvokedTime = valueInstancesInstance["LastInvokedTime"].asString();
if(!valueInstancesInstance["Connected"].isNull())
instancesObject.connected = valueInstancesInstance["Connected"].asString() == "true";
instances_.push_back(instancesObject);
}
if(!value["TotalCount"].isNull())
totalCount_ = std::stol(value["TotalCount"].asString());
if(!value["PageNumber"].isNull())
pageNumber_ = std::stol(value["PageNumber"].asString());
if(!value["PageSize"].isNull())
pageSize_ = std::stol(value["PageSize"].asString());
}
std::vector<DescribeManagedInstancesResult::Instance> DescribeManagedInstancesResult::getInstances()const
{
return instances_;
}
long DescribeManagedInstancesResult::getTotalCount()const
{
return totalCount_;
}
long DescribeManagedInstancesResult::getPageSize()const
{
return pageSize_;
}
long DescribeManagedInstancesResult::getPageNumber()const
{
return pageNumber_;
}

154
ecs/src/model/DescribeSnapshotGroupsRequest.cc Normal file
View File

@@ -0,0 +1,154 @@
/*
* 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/ecs/model/DescribeSnapshotGroupsRequest.h>
using AlibabaCloud::Ecs::Model::DescribeSnapshotGroupsRequest;
DescribeSnapshotGroupsRequest::DescribeSnapshotGroupsRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DescribeSnapshotGroups")
{
setMethod(HttpRequest::Method::Post);
}
DescribeSnapshotGroupsRequest::~DescribeSnapshotGroupsRequest()
{}
long DescribeSnapshotGroupsRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeSnapshotGroupsRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeSnapshotGroupsRequest::getRegionId()const
{
return regionId_;
}
void DescribeSnapshotGroupsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeSnapshotGroupsRequest::getNextToken()const
{
return nextToken_;
}
void DescribeSnapshotGroupsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
}
std::string DescribeSnapshotGroupsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeSnapshotGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeSnapshotGroupsRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeSnapshotGroupsRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::vector<std::string> DescribeSnapshotGroupsRequest::getSnapshotGroupId()const
{
return snapshotGroupId_;
}
void DescribeSnapshotGroupsRequest::setSnapshotGroupId(const std::vector<std::string>& snapshotGroupId)
{
snapshotGroupId_ = snapshotGroupId;
for(int dep1 = 0; dep1!= snapshotGroupId.size(); dep1++) {
setParameter("SnapshotGroupId."+ std::to_string(dep1), snapshotGroupId.at(dep1));
}
}
long DescribeSnapshotGroupsRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeSnapshotGroupsRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeSnapshotGroupsRequest::getInstanceId()const
{
return instanceId_;
}
void DescribeSnapshotGroupsRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setParameter("InstanceId", instanceId);
}
std::string DescribeSnapshotGroupsRequest::getName()const
{
return name_;
}
void DescribeSnapshotGroupsRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}
int DescribeSnapshotGroupsRequest::getMaxResults()const
{
return maxResults_;
}
void DescribeSnapshotGroupsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
}
std::vector<std::string> DescribeSnapshotGroupsRequest::getStatus()const
{
return status_;
}
void DescribeSnapshotGroupsRequest::setStatus(const std::vector<std::string>& status)
{
status_ = status;
for(int dep1 = 0; dep1!= status.size(); dep1++) {
setParameter("Status."+ std::to_string(dep1), status.at(dep1));
}
}

90
ecs/src/model/DescribeSnapshotGroupsResult.cc Normal file
View File

@@ -0,0 +1,90 @@
/*
* 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/ecs/model/DescribeSnapshotGroupsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DescribeSnapshotGroupsResult::DescribeSnapshotGroupsResult() :
ServiceResult()
{}
DescribeSnapshotGroupsResult::DescribeSnapshotGroupsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeSnapshotGroupsResult::~DescribeSnapshotGroupsResult()
{}
void DescribeSnapshotGroupsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allSnapshotGroupsNode = value["SnapshotGroups"]["SnapshotGroup"];
for (auto valueSnapshotGroupsSnapshotGroup : allSnapshotGroupsNode)
{
SnapshotGroup snapshotGroupsObject;
if(!valueSnapshotGroupsSnapshotGroup["InstanceId"].isNull())
snapshotGroupsObject.instanceId = valueSnapshotGroupsSnapshotGroup["InstanceId"].asString();
if(!valueSnapshotGroupsSnapshotGroup["SnapshotGroupId"].isNull())
snapshotGroupsObject.snapshotGroupId = valueSnapshotGroupsSnapshotGroup["SnapshotGroupId"].asString();
if(!valueSnapshotGroupsSnapshotGroup["Status"].isNull())
snapshotGroupsObject.status = valueSnapshotGroupsSnapshotGroup["Status"].asString();
if(!valueSnapshotGroupsSnapshotGroup["Name"].isNull())
snapshotGroupsObject.name = valueSnapshotGroupsSnapshotGroup["Name"].asString();
if(!valueSnapshotGroupsSnapshotGroup["Description"].isNull())
snapshotGroupsObject.description = valueSnapshotGroupsSnapshotGroup["Description"].asString();
if(!valueSnapshotGroupsSnapshotGroup["CreationTime"].isNull())
snapshotGroupsObject.creationTime = valueSnapshotGroupsSnapshotGroup["CreationTime"].asString();
auto allSnapshotsNode = valueSnapshotGroupsSnapshotGroup["Snapshots"]["Snapshot"];
for (auto valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot : allSnapshotsNode)
{
SnapshotGroup::Snapshot snapshotsObject;
if(!valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["SnapshotId"].isNull())
snapshotsObject.snapshotId = valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["SnapshotId"].asString();
if(!valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["Progress"].isNull())
snapshotsObject.progress = valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["Progress"].asString();
if(!valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["SourceDiskId"].isNull())
snapshotsObject.sourceDiskId = valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["SourceDiskId"].asString();
if(!valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["SourceDiskType"].isNull())
snapshotsObject.sourceDiskType = valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["SourceDiskType"].asString();
if(!valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["InstantAccess"].isNull())
snapshotsObject.instantAccess = valueSnapshotGroupsSnapshotGroupSnapshotsSnapshot["InstantAccess"].asString() == "true";
snapshotGroupsObject.snapshots.push_back(snapshotsObject);
}
snapshotGroups_.push_back(snapshotGroupsObject);
}
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
}
std::string DescribeSnapshotGroupsResult::getNextToken()const
{
return nextToken_;
}
std::vector<DescribeSnapshotGroupsResult::SnapshotGroup> DescribeSnapshotGroupsResult::getSnapshotGroups()const
{
return snapshotGroups_;
}

95
ecs/src/model/DisableActivationRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* 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/ecs/model/DisableActivationRequest.h>
using AlibabaCloud::Ecs::Model::DisableActivationRequest;
DisableActivationRequest::DisableActivationRequest() :
RpcServiceRequest("ecs", "2014-05-26", "DisableActivation")
{
setMethod(HttpRequest::Method::Post);
}
DisableActivationRequest::~DisableActivationRequest()
{}
long DisableActivationRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DisableActivationRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DisableActivationRequest::getRegionId()const
{
return regionId_;
}
void DisableActivationRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DisableActivationRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DisableActivationRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DisableActivationRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DisableActivationRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DisableActivationRequest::getOwnerId()const
{
return ownerId_;
}
void DisableActivationRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DisableActivationRequest::getActivationId()const
{
return activationId_;
}
void DisableActivationRequest::setActivationId(const std::string& activationId)
{
activationId_ = activationId;
setParameter("ActivationId", activationId);
}

70
ecs/src/model/DisableActivationResult.cc Normal file
View File

@@ -0,0 +1,70 @@
/*
* 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/ecs/model/DisableActivationResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
DisableActivationResult::DisableActivationResult() :
ServiceResult()
{}
DisableActivationResult::DisableActivationResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DisableActivationResult::~DisableActivationResult()
{}
void DisableActivationResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto activationNode = value["Activation"];
if(!activationNode["ActivationId"].isNull())
activation_.activationId = activationNode["ActivationId"].asString();
if(!activationNode["InstanceName"].isNull())
activation_.instanceName = activationNode["InstanceName"].asString();
if(!activationNode["Description"].isNull())
activation_.description = activationNode["Description"].asString();
if(!activationNode["InstanceCount"].isNull())
activation_.instanceCount = std::stoi(activationNode["InstanceCount"].asString());
if(!activationNode["TimeToLiveInHours"].isNull())
activation_.timeToLiveInHours = std::stol(activationNode["TimeToLiveInHours"].asString());
if(!activationNode["IpAddressRange"].isNull())
activation_.ipAddressRange = activationNode["IpAddressRange"].asString();
if(!activationNode["RegisteredCount"].isNull())
activation_.registeredCount = std::stoi(activationNode["RegisteredCount"].asString());
if(!activationNode["DeregisteredCount"].isNull())
activation_.deregisteredCount = std::stoi(activationNode["DeregisteredCount"].asString());
if(!activationNode["Disabled"].isNull())
activation_.disabled = activationNode["Disabled"].asString() == "true";
if(!activationNode["CreationTime"].isNull())
activation_.creationTime = activationNode["CreationTime"].asString();
}
DisableActivationResult::Activation DisableActivationResult::getActivation()const
{
return activation_;
}

7
ecs/src/model/ModifyDiskSpecResult.cc
View File

@@ -41,6 +41,8 @@ void ModifyDiskSpecResult::parse(const std::string &payload)
setRequestId(value["RequestId"].asString());
if(!value["TaskId"].isNull())
taskId_ = value["TaskId"].asString();
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
}
@@ -49,3 +51,8 @@ std::string ModifyDiskSpecResult::getTaskId()const
return taskId_;
}
std::string ModifyDiskSpecResult::getOrderId()const
{
return orderId_;
}

106
ecs/src/model/ModifyManagedInstanceRequest.cc Normal file
View File

@@ -0,0 +1,106 @@
/*
* 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/ecs/model/ModifyManagedInstanceRequest.h>
using AlibabaCloud::Ecs::Model::ModifyManagedInstanceRequest;
ModifyManagedInstanceRequest::ModifyManagedInstanceRequest() :
RpcServiceRequest("ecs", "2014-05-26", "ModifyManagedInstance")
{
setMethod(HttpRequest::Method::Post);
}
ModifyManagedInstanceRequest::~ModifyManagedInstanceRequest()
{}
long ModifyManagedInstanceRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void ModifyManagedInstanceRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string ModifyManagedInstanceRequest::getRegionId()const
{
return regionId_;
}
void ModifyManagedInstanceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ModifyManagedInstanceRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ModifyManagedInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ModifyManagedInstanceRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void ModifyManagedInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long ModifyManagedInstanceRequest::getOwnerId()const
{
return ownerId_;
}
void ModifyManagedInstanceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyManagedInstanceRequest::getInstanceId()const
{
return instanceId_;
}
void ModifyManagedInstanceRequest::setInstanceId(const std::string& instanceId)
{
instanceId_ = instanceId;
setParameter("InstanceId", instanceId);
}
std::string ModifyManagedInstanceRequest::getInstanceName()const
{
return instanceName_;
}
void ModifyManagedInstanceRequest::setInstanceName(const std::string& instanceName)
{
instanceName_ = instanceName;
setParameter("InstanceName", instanceName);
}

54
ecs/src/model/ModifyManagedInstanceResult.cc Normal file
View File

@@ -0,0 +1,54 @@
/*
* 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/ecs/model/ModifyManagedInstanceResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
ModifyManagedInstanceResult::ModifyManagedInstanceResult() :
ServiceResult()
{}
ModifyManagedInstanceResult::ModifyManagedInstanceResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ModifyManagedInstanceResult::~ModifyManagedInstanceResult()
{}
void ModifyManagedInstanceResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto instanceNode = value["Instance"];
if(!instanceNode["InstanceId"].isNull())
instance_.instanceId = instanceNode["InstanceId"].asString();
if(!instanceNode["InstanceName"].isNull())
instance_.instanceName = instanceNode["InstanceName"].asString();
}
ModifyManagedInstanceResult::Instance ModifyManagedInstanceResult::getInstance()const
{
return instance_;
}

117
ecs/src/model/ModifySnapshotGroupRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* 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/ecs/model/ModifySnapshotGroupRequest.h>
using AlibabaCloud::Ecs::Model::ModifySnapshotGroupRequest;
ModifySnapshotGroupRequest::ModifySnapshotGroupRequest() :
RpcServiceRequest("ecs", "2014-05-26", "ModifySnapshotGroup")
{
setMethod(HttpRequest::Method::Post);
}
ModifySnapshotGroupRequest::~ModifySnapshotGroupRequest()
{}
long ModifySnapshotGroupRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void ModifySnapshotGroupRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string ModifySnapshotGroupRequest::getDescription()const
{
return description_;
}
void ModifySnapshotGroupRequest::setDescription(const std::string& description)
{
description_ = description;
setParameter("Description", description);
}
std::string ModifySnapshotGroupRequest::getRegionId()const
{
return regionId_;
}
void ModifySnapshotGroupRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ModifySnapshotGroupRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ModifySnapshotGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ModifySnapshotGroupRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void ModifySnapshotGroupRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string ModifySnapshotGroupRequest::getSnapshotGroupId()const
{
return snapshotGroupId_;
}
void ModifySnapshotGroupRequest::setSnapshotGroupId(const std::string& snapshotGroupId)
{
snapshotGroupId_ = snapshotGroupId;
setParameter("SnapshotGroupId", snapshotGroupId);
}
long ModifySnapshotGroupRequest::getOwnerId()const
{
return ownerId_;
}
void ModifySnapshotGroupRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifySnapshotGroupRequest::getName()const
{
return name_;
}
void ModifySnapshotGroupRequest::setName(const std::string& name)
{
name_ = name;
setParameter("Name", name);
}

44
ecs/src/model/ModifySnapshotGroupResult.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/ecs/model/ModifySnapshotGroupResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
ModifySnapshotGroupResult::ModifySnapshotGroupResult() :
ServiceResult()
{}
ModifySnapshotGroupResult::ModifySnapshotGroupResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ModifySnapshotGroupResult::~ModifySnapshotGroupResult()
{}
void ModifySnapshotGroupResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

100
ecs/src/model/ResetDisksRequest.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/ecs/model/ResetDisksRequest.h>
using AlibabaCloud::Ecs::Model::ResetDisksRequest;
ResetDisksRequest::ResetDisksRequest() :
RpcServiceRequest("ecs", "2014-05-26", "ResetDisks")
{
setMethod(HttpRequest::Method::Post);
}
ResetDisksRequest::~ResetDisksRequest()
{}
long ResetDisksRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void ResetDisksRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string ResetDisksRequest::getRegionId()const
{
return regionId_;
}
void ResetDisksRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ResetDisksRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void ResetDisksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string ResetDisksRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void ResetDisksRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long ResetDisksRequest::getOwnerId()const
{
return ownerId_;
}
void ResetDisksRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::vector<ResetDisksRequest::Disk> ResetDisksRequest::getDisk()const
{
return disk_;
}
void ResetDisksRequest::setDisk(const std::vector<Disk>& disk)
{
disk_ = disk;
for(int dep1 = 0; dep1!= disk.size(); dep1++) {
auto diskObj = disk.at(dep1);
std::string diskObjStr = "Disk." + std::to_string(dep1 + 1);
setParameter(diskObjStr + ".DiskId", diskObj.diskId);
setParameter(diskObjStr + ".SnapshotId", diskObj.snapshotId);
}
}

71
ecs/src/model/ResetDisksResult.cc Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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/ecs/model/ResetDisksResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
ResetDisksResult::ResetDisksResult() :
ServiceResult()
{}
ResetDisksResult::ResetDisksResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ResetDisksResult::~ResetDisksResult()
{}
void ResetDisksResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allOperationProgressSetNode = value["OperationProgressSet"]["OperationProgress"];
for (auto valueOperationProgressSetOperationProgress : allOperationProgressSetNode)
{
OperationProgress operationProgressSetObject;
if(!valueOperationProgressSetOperationProgress["OperationStatus"].isNull())
operationProgressSetObject.operationStatus = valueOperationProgressSetOperationProgress["OperationStatus"].asString();
if(!valueOperationProgressSetOperationProgress["ErrorCode"].isNull())
operationProgressSetObject.errorCode = valueOperationProgressSetOperationProgress["ErrorCode"].asString();
if(!valueOperationProgressSetOperationProgress["ErrorMsg"].isNull())
operationProgressSetObject.errorMsg = valueOperationProgressSetOperationProgress["ErrorMsg"].asString();
auto allRelatedItemSetNode = valueOperationProgressSetOperationProgress["RelatedItemSet"]["RelatedItem"];
for (auto valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem : allRelatedItemSetNode)
{
OperationProgress::RelatedItem relatedItemSetObject;
if(!valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem["Name"].isNull())
relatedItemSetObject.name = valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem["Name"].asString();
if(!valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem["Value"].isNull())
relatedItemSetObject.value = valueOperationProgressSetOperationProgressRelatedItemSetRelatedItem["Value"].asString();
operationProgressSetObject.relatedItemSet.push_back(relatedItemSetObject);
}
operationProgressSet_.push_back(operationProgressSetObject);
}
}
std::vector<ResetDisksResult::OperationProgress> ResetDisksResult::getOperationProgressSet()const
{
return operationProgressSet_;
}

7
ecs/src/model/ResizeDiskResult.cc
View File

@@ -39,6 +39,13 @@ void ResizeDiskResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["OrderId"].isNull())
orderId_ = value["OrderId"].asString();
}
std::string ResizeDiskResult::getOrderId()const
{
return orderId_;
}

11
ecs/src/model/RunInstancesRequest.cc
View File

@@ -407,6 +407,17 @@ void RunInstancesRequest::setResourceOwnerAccount(const std::string& resourceOwn
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string RunInstancesRequest::getSchedulerOptionsDedicatedHostClusterId()const
{
return schedulerOptionsDedicatedHostClusterId_;
}
void RunInstancesRequest::setSchedulerOptionsDedicatedHostClusterId(const std::string& schedulerOptionsDedicatedHostClusterId)
{
schedulerOptionsDedicatedHostClusterId_ = schedulerOptionsDedicatedHostClusterId;
setParameter("SchedulerOptionsDedicatedHostClusterId", schedulerOptionsDedicatedHostClusterId);
}
std::string RunInstancesRequest::getSystemDiskDiskName()const
{
return systemDiskDiskName_;

122
ecs/src/model/StartImagePipelineExecutionRequest.cc Normal file
View File

@@ -0,0 +1,122 @@
/*
* 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/ecs/model/StartImagePipelineExecutionRequest.h>
using AlibabaCloud::Ecs::Model::StartImagePipelineExecutionRequest;
StartImagePipelineExecutionRequest::StartImagePipelineExecutionRequest() :
RpcServiceRequest("ecs", "2014-05-26", "StartImagePipelineExecution")
{
setMethod(HttpRequest::Method::Post);
}
StartImagePipelineExecutionRequest::~StartImagePipelineExecutionRequest()
{}
std::string StartImagePipelineExecutionRequest::getImagePipelineId()const
{
return imagePipelineId_;
}
void StartImagePipelineExecutionRequest::setImagePipelineId(const std::string& imagePipelineId)
{
imagePipelineId_ = imagePipelineId;
setParameter("ImagePipelineId", imagePipelineId);
}
long StartImagePipelineExecutionRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void StartImagePipelineExecutionRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string StartImagePipelineExecutionRequest::getClientToken()const
{
return clientToken_;
}
void StartImagePipelineExecutionRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string StartImagePipelineExecutionRequest::getRegionId()const
{
return regionId_;
}
void StartImagePipelineExecutionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::vector<StartImagePipelineExecutionRequest::TemplateTag> StartImagePipelineExecutionRequest::getTemplateTag()const
{
return templateTag_;
}
void StartImagePipelineExecutionRequest::setTemplateTag(const std::vector<TemplateTag>& templateTag)
{
templateTag_ = templateTag;
for(int dep1 = 0; dep1!= templateTag.size(); dep1++) {
auto templateTagObj = templateTag.at(dep1);
std::string templateTagObjStr = "TemplateTag." + std::to_string(dep1 + 1);
setParameter(templateTagObjStr + ".Key", templateTagObj.key);
setParameter(templateTagObjStr + ".Value", templateTagObj.value);
}
}
std::string StartImagePipelineExecutionRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void StartImagePipelineExecutionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string StartImagePipelineExecutionRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void StartImagePipelineExecutionRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long StartImagePipelineExecutionRequest::getOwnerId()const
{
return ownerId_;
}
void StartImagePipelineExecutionRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

51
ecs/src/model/StartImagePipelineExecutionResult.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/ecs/model/StartImagePipelineExecutionResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ecs;
using namespace AlibabaCloud::Ecs::Model;
StartImagePipelineExecutionResult::StartImagePipelineExecutionResult() :
ServiceResult()
{}
StartImagePipelineExecutionResult::StartImagePipelineExecutionResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
StartImagePipelineExecutionResult::~StartImagePipelineExecutionResult()
{}
void StartImagePipelineExecutionResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["ExecutionId"].isNull())
executionId_ = value["ExecutionId"].asString();
}
std::string StartImagePipelineExecutionResult::getExecutionId()const
{
return executionId_;
}