JsonValue Instance::Jsonize() const
{
JsonValue payload;
if(m_agentVersionHasBeenSet)
{
payload.WithString("AgentVersion", m_agentVersion);
}
if(m_amiIdHasBeenSet)
{
payload.WithString("AmiId", m_amiId);
}
if(m_architectureHasBeenSet)
{
payload.WithString("Architecture", ArchitectureMapper::GetNameForArchitecture(m_architecture));
}
if(m_autoScalingTypeHasBeenSet)
{
payload.WithString("AutoScalingType", AutoScalingTypeMapper::GetNameForAutoScalingType(m_autoScalingType));
}
if(m_availabilityZoneHasBeenSet)
{
payload.WithString("AvailabilityZone", m_availabilityZone);
}
if(m_blockDeviceMappingsHasBeenSet)
{
Array<JsonValue> blockDeviceMappingsJsonList(m_blockDeviceMappings.size());
for(unsigned blockDeviceMappingsIndex = 0; blockDeviceMappingsIndex < blockDeviceMappingsJsonList.GetLength(); ++blockDeviceMappingsIndex)
{
blockDeviceMappingsJsonList[blockDeviceMappingsIndex].AsObject(m_blockDeviceMappings[blockDeviceMappingsIndex].Jsonize());
}
payload.WithArray("BlockDeviceMappings", std::move(blockDeviceMappingsJsonList));
}
if(m_createdAtHasBeenSet)
{
payload.WithString("CreatedAt", m_createdAt);
}
if(m_ebsOptimizedHasBeenSet)
{
payload.WithBool("EbsOptimized", m_ebsOptimized);
}
if(m_ec2InstanceIdHasBeenSet)
{
payload.WithString("Ec2InstanceId", m_ec2InstanceId);
}
if(m_ecsClusterArnHasBeenSet)
{
payload.WithString("EcsClusterArn", m_ecsClusterArn);
}
if(m_ecsContainerInstanceArnHasBeenSet)
{
payload.WithString("EcsContainerInstanceArn", m_ecsContainerInstanceArn);
}
if(m_elasticIpHasBeenSet)
{
payload.WithString("ElasticIp", m_elasticIp);
}
if(m_hostnameHasBeenSet)
{
payload.WithString("Hostname", m_hostname);
}
if(m_infrastructureClassHasBeenSet)
{
payload.WithString("InfrastructureClass", m_infrastructureClass);
}
if(m_installUpdatesOnBootHasBeenSet)
{
payload.WithBool("InstallUpdatesOnBoot", m_installUpdatesOnBoot);
}
if(m_instanceIdHasBeenSet)
{
payload.WithString("InstanceId", m_instanceId);
}
if(m_instanceProfileArnHasBeenSet)
{
payload.WithString("InstanceProfileArn", m_instanceProfileArn);
}
if(m_instanceTypeHasBeenSet)
{
payload.WithString("InstanceType", m_instanceType);
}
if(m_lastServiceErrorIdHasBeenSet)
{
payload.WithString("LastServiceErrorId", m_lastServiceErrorId);
}
if(m_layerIdsHasBeenSet)
{
Array<JsonValue> layerIdsJsonList(m_layerIds.size());
for(unsigned layerIdsIndex = 0; layerIdsIndex < layerIdsJsonList.GetLength(); ++layerIdsIndex)
{
layerIdsJsonList[layerIdsIndex].AsString(m_layerIds[layerIdsIndex]);
}
payload.WithArray("LayerIds", std::move(layerIdsJsonList));
}
if(m_osHasBeenSet)
{
payload.WithString("Os", m_os);
}
if(m_platformHasBeenSet)
{
payload.WithString("Platform", m_platform);
}
if(m_privateDnsHasBeenSet)
{
payload.WithString("PrivateDns", m_privateDns);
}
if(m_privateIpHasBeenSet)
{
payload.WithString("PrivateIp", m_privateIp);
}
if(m_publicDnsHasBeenSet)
{
payload.WithString("PublicDns", m_publicDns);
}
if(m_publicIpHasBeenSet)
{
payload.WithString("PublicIp", m_publicIp);
}
if(m_registeredByHasBeenSet)
{
payload.WithString("RegisteredBy", m_registeredBy);
}
if(m_reportedAgentVersionHasBeenSet)
{
payload.WithString("ReportedAgentVersion", m_reportedAgentVersion);
}
if(m_reportedOsHasBeenSet)
{
payload.WithObject("ReportedOs", m_reportedOs.Jsonize());
}
if(m_rootDeviceTypeHasBeenSet)
{
payload.WithString("RootDeviceType", RootDeviceTypeMapper::GetNameForRootDeviceType(m_rootDeviceType));
}
if(m_rootDeviceVolumeIdHasBeenSet)
{
payload.WithString("RootDeviceVolumeId", m_rootDeviceVolumeId);
}
if(m_securityGroupIdsHasBeenSet)
{
Array<JsonValue> securityGroupIdsJsonList(m_securityGroupIds.size());
for(unsigned securityGroupIdsIndex = 0; securityGroupIdsIndex < securityGroupIdsJsonList.GetLength(); ++securityGroupIdsIndex)
{
securityGroupIdsJsonList[securityGroupIdsIndex].AsString(m_securityGroupIds[securityGroupIdsIndex]);
}
payload.WithArray("SecurityGroupIds", std::move(securityGroupIdsJsonList));
}
if(m_sshHostDsaKeyFingerprintHasBeenSet)
{
payload.WithString("SshHostDsaKeyFingerprint", m_sshHostDsaKeyFingerprint);
}
if(m_sshHostRsaKeyFingerprintHasBeenSet)
{
payload.WithString("SshHostRsaKeyFingerprint", m_sshHostRsaKeyFingerprint);
}
if(m_sshKeyNameHasBeenSet)
{
payload.WithString("SshKeyName", m_sshKeyName);
}
if(m_stackIdHasBeenSet)
{
payload.WithString("StackId", m_stackId);
}
if(m_statusHasBeenSet)
{
payload.WithString("Status", m_status);
}
if(m_subnetIdHasBeenSet)
{
payload.WithString("SubnetId", m_subnetId);
}
if(m_tenancyHasBeenSet)
{
payload.WithString("Tenancy", m_tenancy);
}
if(m_virtualizationTypeHasBeenSet)
{
payload.WithString("VirtualizationType", VirtualizationTypeMapper::GetNameForVirtualizationType(m_virtualizationType));
}
return payload;
}
Aws::String CreateAssociationRequest::SerializePayload() const
{
JsonValue payload;
if(m_nameHasBeenSet)
{
payload.WithString("Name", m_name);
}
if(m_documentVersionHasBeenSet)
{
payload.WithString("DocumentVersion", m_documentVersion);
}
if(m_instanceIdHasBeenSet)
{
payload.WithString("InstanceId", m_instanceId);
}
if(m_parametersHasBeenSet)
{
JsonValue parametersJsonMap;
for(auto& parametersItem : m_parameters)
{
Array<JsonValue> parameterValueListJsonList(parametersItem.second.size());
for(unsigned parameterValueListIndex = 0; parameterValueListIndex < parameterValueListJsonList.GetLength(); ++parameterValueListIndex)
{
parameterValueListJsonList[parameterValueListIndex].AsString(parametersItem.second[parameterValueListIndex]);
}
parametersJsonMap.WithArray(parametersItem.first, std::move(parameterValueListJsonList));
}
payload.WithObject("Parameters", std::move(parametersJsonMap));
}
if(m_targetsHasBeenSet)
{
Array<JsonValue> targetsJsonList(m_targets.size());
for(unsigned targetsIndex = 0; targetsIndex < targetsJsonList.GetLength(); ++targetsIndex)
{
targetsJsonList[targetsIndex].AsObject(m_targets[targetsIndex].Jsonize());
}
payload.WithArray("Targets", std::move(targetsJsonList));
}
if(m_scheduleExpressionHasBeenSet)
{
payload.WithString("ScheduleExpression", m_scheduleExpression);
}
if(m_outputLocationHasBeenSet)
{
payload.WithObject("OutputLocation", m_outputLocation.Jsonize());
}
return payload.WriteReadable();
}
JsonValue TableDescription::Jsonize() const
{
JsonValue payload;
if(m_attributeDefinitionsHasBeenSet)
{
Array<JsonValue> attributeDefinitionsJsonList(m_attributeDefinitions.size());
for(unsigned attributeDefinitionsIndex = 0; attributeDefinitionsIndex < attributeDefinitionsJsonList.GetLength(); ++attributeDefinitionsIndex)
{
attributeDefinitionsJsonList[attributeDefinitionsIndex].AsObject(m_attributeDefinitions[attributeDefinitionsIndex].Jsonize());
}
payload.WithArray("AttributeDefinitions", std::move(attributeDefinitionsJsonList));
}
if(m_tableNameHasBeenSet)
{
payload.WithString("TableName", m_tableName);
}
if(m_keySchemaHasBeenSet)
{
Array<JsonValue> keySchemaJsonList(m_keySchema.size());
for(unsigned keySchemaIndex = 0; keySchemaIndex < keySchemaJsonList.GetLength(); ++keySchemaIndex)
{
keySchemaJsonList[keySchemaIndex].AsObject(m_keySchema[keySchemaIndex].Jsonize());
}
payload.WithArray("KeySchema", std::move(keySchemaJsonList));
}
if(m_tableStatusHasBeenSet)
{
payload.WithString("TableStatus", TableStatusMapper::GetNameForTableStatus(m_tableStatus));
}
if(m_creationDateTimeHasBeenSet)
{
payload.WithString("CreationDateTime", m_creationDateTime);
}
if(m_provisionedThroughputHasBeenSet)
{
payload.WithObject("ProvisionedThroughput", m_provisionedThroughput.Jsonize());
}
if(m_tableSizeBytesHasBeenSet)
{
payload.WithInt64("TableSizeBytes", m_tableSizeBytes);
}
if(m_itemCountHasBeenSet)
{
payload.WithInt64("ItemCount", m_itemCount);
}
if(m_tableArnHasBeenSet)
{
payload.WithString("TableArn", m_tableArn);
}
if(m_localSecondaryIndexesHasBeenSet)
{
Array<JsonValue> localSecondaryIndexesJsonList(m_localSecondaryIndexes.size());
for(unsigned localSecondaryIndexesIndex = 0; localSecondaryIndexesIndex < localSecondaryIndexesJsonList.GetLength(); ++localSecondaryIndexesIndex)
{
localSecondaryIndexesJsonList[localSecondaryIndexesIndex].AsObject(m_localSecondaryIndexes[localSecondaryIndexesIndex].Jsonize());
}
payload.WithArray("LocalSecondaryIndexes", std::move(localSecondaryIndexesJsonList));
}
if(m_globalSecondaryIndexesHasBeenSet)
{
Array<JsonValue> globalSecondaryIndexesJsonList(m_globalSecondaryIndexes.size());
for(unsigned globalSecondaryIndexesIndex = 0; globalSecondaryIndexesIndex < globalSecondaryIndexesJsonList.GetLength(); ++globalSecondaryIndexesIndex)
{
globalSecondaryIndexesJsonList[globalSecondaryIndexesIndex].AsObject(m_globalSecondaryIndexes[globalSecondaryIndexesIndex].Jsonize());
}
payload.WithArray("GlobalSecondaryIndexes", std::move(globalSecondaryIndexesJsonList));
}
if(m_streamSpecificationHasBeenSet)
{
payload.WithObject("StreamSpecification", m_streamSpecification.Jsonize());
}
if(m_latestStreamLabelHasBeenSet)
{
payload.WithString("LatestStreamLabel", m_latestStreamLabel);
}
if(m_latestStreamArnHasBeenSet)
{
payload.WithString("LatestStreamArn", m_latestStreamArn);
}
return std::move(payload);
}
Aws::String CreateHITRequest::SerializePayload() const
{
JsonValue payload;
if(m_maxAssignmentsHasBeenSet)
{
payload.WithInteger("MaxAssignments", m_maxAssignments);
}
if(m_autoApprovalDelayInSecondsHasBeenSet)
{
payload.WithInt64("AutoApprovalDelayInSeconds", m_autoApprovalDelayInSeconds);
}
if(m_lifetimeInSecondsHasBeenSet)
{
payload.WithInt64("LifetimeInSeconds", m_lifetimeInSeconds);
}
if(m_assignmentDurationInSecondsHasBeenSet)
{
payload.WithInt64("AssignmentDurationInSeconds", m_assignmentDurationInSeconds);
}
if(m_rewardHasBeenSet)
{
payload.WithString("Reward", m_reward);
}
if(m_titleHasBeenSet)
{
payload.WithString("Title", m_title);
}
if(m_keywordsHasBeenSet)
{
payload.WithString("Keywords", m_keywords);
}
if(m_descriptionHasBeenSet)
{
payload.WithString("Description", m_description);
}
if(m_questionHasBeenSet)
{
payload.WithString("Question", m_question);
}
if(m_requesterAnnotationHasBeenSet)
{
payload.WithString("RequesterAnnotation", m_requesterAnnotation);
}
if(m_qualificationRequirementsHasBeenSet)
{
Array<JsonValue> qualificationRequirementsJsonList(m_qualificationRequirements.size());
for(unsigned qualificationRequirementsIndex = 0; qualificationRequirementsIndex < qualificationRequirementsJsonList.GetLength(); ++qualificationRequirementsIndex)
{
qualificationRequirementsJsonList[qualificationRequirementsIndex].AsObject(m_qualificationRequirements[qualificationRequirementsIndex].Jsonize());
}
payload.WithArray("QualificationRequirements", std::move(qualificationRequirementsJsonList));
}
if(m_uniqueRequestTokenHasBeenSet)
{
payload.WithString("UniqueRequestToken", m_uniqueRequestToken);
}
if(m_assignmentReviewPolicyHasBeenSet)
{
payload.WithObject("AssignmentReviewPolicy", m_assignmentReviewPolicy.Jsonize());
}
if(m_hITReviewPolicyHasBeenSet)
{
payload.WithObject("HITReviewPolicy", m_hITReviewPolicy.Jsonize());
}
if(m_hITLayoutIdHasBeenSet)
{
payload.WithString("HITLayoutId", m_hITLayoutId);
}
if(m_hITLayoutParametersHasBeenSet)
{
Array<JsonValue> hITLayoutParametersJsonList(m_hITLayoutParameters.size());
for(unsigned hITLayoutParametersIndex = 0; hITLayoutParametersIndex < hITLayoutParametersJsonList.GetLength(); ++hITLayoutParametersIndex)
{
hITLayoutParametersJsonList[hITLayoutParametersIndex].AsObject(m_hITLayoutParameters[hITLayoutParametersIndex].Jsonize());
}
payload.WithArray("HITLayoutParameters", std::move(hITLayoutParametersJsonList));
}
return payload.WriteReadable();
}
JsonValue WriteCampaignRequest::Jsonize() const
{
JsonValue payload;
if(m_additionalTreatmentsHasBeenSet)
{
Array<JsonValue> additionalTreatmentsJsonList(m_additionalTreatments.size());
for(unsigned additionalTreatmentsIndex = 0; additionalTreatmentsIndex < additionalTreatmentsJsonList.GetLength(); ++additionalTreatmentsIndex)
{
additionalTreatmentsJsonList[additionalTreatmentsIndex].AsObject(m_additionalTreatments[additionalTreatmentsIndex].Jsonize());
}
payload.WithArray("AdditionalTreatments", std::move(additionalTreatmentsJsonList));
}
if(m_descriptionHasBeenSet)
{
payload.WithString("Description", m_description);
}
if(m_holdoutPercentHasBeenSet)
{
payload.WithInteger("HoldoutPercent", m_holdoutPercent);
}
if(m_isPausedHasBeenSet)
{
payload.WithBool("IsPaused", m_isPaused);
}
if(m_limitsHasBeenSet)
{
payload.WithObject("Limits", m_limits.Jsonize());
}
if(m_messageConfigurationHasBeenSet)
{
payload.WithObject("MessageConfiguration", m_messageConfiguration.Jsonize());
}
if(m_nameHasBeenSet)
{
payload.WithString("Name", m_name);
}
if(m_scheduleHasBeenSet)
{
payload.WithObject("Schedule", m_schedule.Jsonize());
}
if(m_segmentIdHasBeenSet)
{
payload.WithString("SegmentId", m_segmentId);
}
if(m_segmentVersionHasBeenSet)
{
payload.WithInteger("SegmentVersion", m_segmentVersion);
}
if(m_treatmentDescriptionHasBeenSet)
{
payload.WithString("TreatmentDescription", m_treatmentDescription);
}
if(m_treatmentNameHasBeenSet)
{
payload.WithString("TreatmentName", m_treatmentName);
}
return payload;
}
Aws::String SendCommandRequest::SerializePayload() const
{
JsonValue payload;
if(m_instanceIdsHasBeenSet)
{
Array<JsonValue> instanceIdsJsonList(m_instanceIds.size());
for(unsigned instanceIdsIndex = 0; instanceIdsIndex < instanceIdsJsonList.GetLength(); ++instanceIdsIndex)
{
instanceIdsJsonList[instanceIdsIndex].AsString(m_instanceIds[instanceIdsIndex]);
}
payload.WithArray("InstanceIds", std::move(instanceIdsJsonList));
}
if(m_targetsHasBeenSet)
{
Array<JsonValue> targetsJsonList(m_targets.size());
for(unsigned targetsIndex = 0; targetsIndex < targetsJsonList.GetLength(); ++targetsIndex)
{
targetsJsonList[targetsIndex].AsObject(m_targets[targetsIndex].Jsonize());
}
payload.WithArray("Targets", std::move(targetsJsonList));
}
if(m_documentNameHasBeenSet)
{
payload.WithString("DocumentName", m_documentName);
}
if(m_documentHashHasBeenSet)
{
payload.WithString("DocumentHash", m_documentHash);
}
if(m_documentHashTypeHasBeenSet)
{
payload.WithString("DocumentHashType", DocumentHashTypeMapper::GetNameForDocumentHashType(m_documentHashType));
}
if(m_timeoutSecondsHasBeenSet)
{
payload.WithInteger("TimeoutSeconds", m_timeoutSeconds);
}
if(m_commentHasBeenSet)
{
payload.WithString("Comment", m_comment);
}
if(m_parametersHasBeenSet)
{
JsonValue parametersJsonMap;
for(auto& parametersItem : m_parameters)
{
Array<JsonValue> parameterValueListJsonList(parametersItem.second.size());
for(unsigned parameterValueListIndex = 0; parameterValueListIndex < parameterValueListJsonList.GetLength(); ++parameterValueListIndex)
{
parameterValueListJsonList[parameterValueListIndex].AsString(parametersItem.second[parameterValueListIndex]);
}
parametersJsonMap.WithArray(parametersItem.first, std::move(parameterValueListJsonList));
}
payload.WithObject("Parameters", std::move(parametersJsonMap));
}
if(m_outputS3RegionHasBeenSet)
{
payload.WithString("OutputS3Region", m_outputS3Region);
}
if(m_outputS3BucketNameHasBeenSet)
{
payload.WithString("OutputS3BucketName", m_outputS3BucketName);
}
if(m_outputS3KeyPrefixHasBeenSet)
{
payload.WithString("OutputS3KeyPrefix", m_outputS3KeyPrefix);
}
if(m_maxConcurrencyHasBeenSet)
{
payload.WithString("MaxConcurrency", m_maxConcurrency);
}
if(m_maxErrorsHasBeenSet)
{
payload.WithString("MaxErrors", m_maxErrors);
}
if(m_serviceRoleArnHasBeenSet)
{
payload.WithString("ServiceRoleArn", m_serviceRoleArn);
}
if(m_notificationConfigHasBeenSet)
{
payload.WithObject("NotificationConfig", m_notificationConfig.Jsonize());
}
return payload.WriteReadable();
}
JsonValue Cluster::Jsonize() const
{
JsonValue payload;
if(m_idHasBeenSet)
{
payload.WithString("Id", m_id);
}
if(m_nameHasBeenSet)
{
payload.WithString("Name", m_name);
}
if(m_statusHasBeenSet)
{
payload.WithObject("Status", m_status.Jsonize());
}
if(m_ec2InstanceAttributesHasBeenSet)
{
payload.WithObject("Ec2InstanceAttributes", m_ec2InstanceAttributes.Jsonize());
}
if(m_logUriHasBeenSet)
{
payload.WithString("LogUri", m_logUri);
}
if(m_requestedAmiVersionHasBeenSet)
{
payload.WithString("RequestedAmiVersion", m_requestedAmiVersion);
}
if(m_runningAmiVersionHasBeenSet)
{
payload.WithString("RunningAmiVersion", m_runningAmiVersion);
}
if(m_releaseLabelHasBeenSet)
{
payload.WithString("ReleaseLabel", m_releaseLabel);
}
if(m_autoTerminateHasBeenSet)
{
payload.WithBool("AutoTerminate", m_autoTerminate);
}
if(m_terminationProtectedHasBeenSet)
{
payload.WithBool("TerminationProtected", m_terminationProtected);
}
if(m_visibleToAllUsersHasBeenSet)
{
payload.WithBool("VisibleToAllUsers", m_visibleToAllUsers);
}
if(m_applicationsHasBeenSet)
{
Array<JsonValue> applicationsJsonList(m_applications.size());
for(unsigned applicationsIndex = 0; applicationsIndex < applicationsJsonList.GetLength(); ++applicationsIndex)
{
applicationsJsonList[applicationsIndex].AsObject(m_applications[applicationsIndex].Jsonize());
}
payload.WithArray("Applications", std::move(applicationsJsonList));
}
if(m_tagsHasBeenSet)
{
Array<JsonValue> tagsJsonList(m_tags.size());
for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
{
tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
}
payload.WithArray("Tags", std::move(tagsJsonList));
}
if(m_serviceRoleHasBeenSet)
{
payload.WithString("ServiceRole", m_serviceRole);
}
if(m_normalizedInstanceHoursHasBeenSet)
{
payload.WithInteger("NormalizedInstanceHours", m_normalizedInstanceHours);
}
if(m_masterPublicDnsNameHasBeenSet)
{
payload.WithString("MasterPublicDnsName", m_masterPublicDnsName);
}
if(m_configurationsHasBeenSet)
{
Array<JsonValue> configurationsJsonList(m_configurations.size());
for(unsigned configurationsIndex = 0; configurationsIndex < configurationsJsonList.GetLength(); ++configurationsIndex)
{
configurationsJsonList[configurationsIndex].AsObject(m_configurations[configurationsIndex].Jsonize());
}
payload.WithArray("Configurations", std::move(configurationsJsonList));
}
return payload;
}
JsonValue EntityFilter::Jsonize() const
{
JsonValue payload;
if(m_eventArnsHasBeenSet)
{
Array<JsonValue> eventArnsJsonList(m_eventArns.size());
for(unsigned eventArnsIndex = 0; eventArnsIndex < eventArnsJsonList.GetLength(); ++eventArnsIndex)
{
eventArnsJsonList[eventArnsIndex].AsString(m_eventArns[eventArnsIndex]);
}
payload.WithArray("eventArns", std::move(eventArnsJsonList));
}
if(m_entityArnsHasBeenSet)
{
Array<JsonValue> entityArnsJsonList(m_entityArns.size());
for(unsigned entityArnsIndex = 0; entityArnsIndex < entityArnsJsonList.GetLength(); ++entityArnsIndex)
{
entityArnsJsonList[entityArnsIndex].AsString(m_entityArns[entityArnsIndex]);
}
payload.WithArray("entityArns", std::move(entityArnsJsonList));
}
if(m_entityValuesHasBeenSet)
{
Array<JsonValue> entityValuesJsonList(m_entityValues.size());
for(unsigned entityValuesIndex = 0; entityValuesIndex < entityValuesJsonList.GetLength(); ++entityValuesIndex)
{
entityValuesJsonList[entityValuesIndex].AsString(m_entityValues[entityValuesIndex]);
}
payload.WithArray("entityValues", std::move(entityValuesJsonList));
}
if(m_lastUpdatedTimesHasBeenSet)
{
Array<JsonValue> lastUpdatedTimesJsonList(m_lastUpdatedTimes.size());
for(unsigned lastUpdatedTimesIndex = 0; lastUpdatedTimesIndex < lastUpdatedTimesJsonList.GetLength(); ++lastUpdatedTimesIndex)
{
lastUpdatedTimesJsonList[lastUpdatedTimesIndex].AsObject(m_lastUpdatedTimes[lastUpdatedTimesIndex].Jsonize());
}
payload.WithArray("lastUpdatedTimes", std::move(lastUpdatedTimesJsonList));
}
if(m_tagsHasBeenSet)
{
Array<JsonValue> tagsJsonList(m_tags.size());
for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
{
JsonValue tagSetJsonMap;
for(auto& tagSetItem : m_tags[tagsIndex])
{
tagSetJsonMap.WithString(tagSetItem.first, tagSetItem.second);
}
tagsJsonList[tagsIndex].AsObject(std::move(tagSetJsonMap));
}
payload.WithArray("tags", std::move(tagsJsonList));
}
if(m_statusCodesHasBeenSet)
{
Array<JsonValue> statusCodesJsonList(m_statusCodes.size());
for(unsigned statusCodesIndex = 0; statusCodesIndex < statusCodesJsonList.GetLength(); ++statusCodesIndex)
{
statusCodesJsonList[statusCodesIndex].AsString(EntityStatusCodeMapper::GetNameForEntityStatusCode(m_statusCodes[statusCodesIndex]));
}
payload.WithArray("statusCodes", std::move(statusCodesJsonList));
}
return payload;
}
Aws::String CreateUserPoolRequest::SerializePayload() const
{
JsonValue payload;
if(m_poolNameHasBeenSet)
{
payload.WithString("PoolName", m_poolName);
}
if(m_policiesHasBeenSet)
{
payload.WithObject("Policies", m_policies.Jsonize());
}
if(m_lambdaConfigHasBeenSet)
{
payload.WithObject("LambdaConfig", m_lambdaConfig.Jsonize());
}
if(m_autoVerifiedAttributesHasBeenSet)
{
Array<JsonValue> autoVerifiedAttributesJsonList(m_autoVerifiedAttributes.size());
for(unsigned autoVerifiedAttributesIndex = 0; autoVerifiedAttributesIndex < autoVerifiedAttributesJsonList.GetLength(); ++autoVerifiedAttributesIndex)
{
autoVerifiedAttributesJsonList[autoVerifiedAttributesIndex].AsString(VerifiedAttributeTypeMapper::GetNameForVerifiedAttributeType(m_autoVerifiedAttributes[autoVerifiedAttributesIndex]));
}
payload.WithArray("AutoVerifiedAttributes", std::move(autoVerifiedAttributesJsonList));
}
if(m_aliasAttributesHasBeenSet)
{
Array<JsonValue> aliasAttributesJsonList(m_aliasAttributes.size());
for(unsigned aliasAttributesIndex = 0; aliasAttributesIndex < aliasAttributesJsonList.GetLength(); ++aliasAttributesIndex)
{
aliasAttributesJsonList[aliasAttributesIndex].AsString(AliasAttributeTypeMapper::GetNameForAliasAttributeType(m_aliasAttributes[aliasAttributesIndex]));
}
payload.WithArray("AliasAttributes", std::move(aliasAttributesJsonList));
}
if(m_smsVerificationMessageHasBeenSet)
{
payload.WithString("SmsVerificationMessage", m_smsVerificationMessage);
}
if(m_emailVerificationMessageHasBeenSet)
{
payload.WithString("EmailVerificationMessage", m_emailVerificationMessage);
}
if(m_emailVerificationSubjectHasBeenSet)
{
payload.WithString("EmailVerificationSubject", m_emailVerificationSubject);
}
if(m_smsAuthenticationMessageHasBeenSet)
{
payload.WithString("SmsAuthenticationMessage", m_smsAuthenticationMessage);
}
if(m_mfaConfigurationHasBeenSet)
{
payload.WithString("MfaConfiguration", UserPoolMfaTypeMapper::GetNameForUserPoolMfaType(m_mfaConfiguration));
}
return payload.WriteReadable();
}
Aws::String CreateReplicationInstanceRequest::SerializePayload() const
{
JsonValue payload;
if(m_replicationInstanceIdentifierHasBeenSet)
{
payload.WithString("ReplicationInstanceIdentifier", m_replicationInstanceIdentifier);
}
if(m_allocatedStorageHasBeenSet)
{
payload.WithInteger("AllocatedStorage", m_allocatedStorage);
}
if(m_replicationInstanceClassHasBeenSet)
{
payload.WithString("ReplicationInstanceClass", m_replicationInstanceClass);
}
if(m_availabilityZoneHasBeenSet)
{
payload.WithString("AvailabilityZone", m_availabilityZone);
}
if(m_replicationSubnetGroupIdentifierHasBeenSet)
{
payload.WithString("ReplicationSubnetGroupIdentifier", m_replicationSubnetGroupIdentifier);
}
if(m_preferredMaintenanceWindowHasBeenSet)
{
payload.WithString("PreferredMaintenanceWindow", m_preferredMaintenanceWindow);
}
if(m_engineVersionHasBeenSet)
{
payload.WithString("EngineVersion", m_engineVersion);
}
if(m_autoMinorVersionUpgradeHasBeenSet)
{
payload.WithBool("AutoMinorVersionUpgrade", m_autoMinorVersionUpgrade);
}
if(m_tagsHasBeenSet)
{
Array<JsonValue> tagsJsonList(m_tags.size());
for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
{
tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
}
payload.WithArray("Tags", std::move(tagsJsonList));
}
if(m_kmsKeyIdHasBeenSet)
{
payload.WithString("KmsKeyId", m_kmsKeyId);
}
if(m_publiclyAccessibleHasBeenSet)
{
payload.WithBool("PubliclyAccessible", m_publiclyAccessible);
}
return payload.WriteReadable();
}
Aws::String CreateEndpointRequest::SerializePayload() const
{
JsonValue payload;
if(m_endpointIdentifierHasBeenSet)
{
payload.WithString("EndpointIdentifier", m_endpointIdentifier);
}
if(m_endpointTypeHasBeenSet)
{
payload.WithString("EndpointType", ReplicationEndpointTypeValueMapper::GetNameForReplicationEndpointTypeValue(m_endpointType));
}
if(m_engineNameHasBeenSet)
{
payload.WithString("EngineName", m_engineName);
}
if(m_usernameHasBeenSet)
{
payload.WithString("Username", m_username);
}
if(m_passwordHasBeenSet)
{
payload.WithString("Password", m_password);
}
if(m_serverNameHasBeenSet)
{
payload.WithString("ServerName", m_serverName);
}
if(m_portHasBeenSet)
{
payload.WithInteger("Port", m_port);
}
if(m_databaseNameHasBeenSet)
{
payload.WithString("DatabaseName", m_databaseName);
}
if(m_extraConnectionAttributesHasBeenSet)
{
payload.WithString("ExtraConnectionAttributes", m_extraConnectionAttributes);
}
if(m_kmsKeyIdHasBeenSet)
{
payload.WithString("KmsKeyId", m_kmsKeyId);
}
if(m_tagsHasBeenSet)
{
Array<JsonValue> tagsJsonList(m_tags.size());
for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
{
tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
}
payload.WithArray("Tags", std::move(tagsJsonList));
}
return payload.WriteReadable();
}
JsonValue StreamDescription::Jsonize() const
{
JsonValue payload;
if(m_streamNameHasBeenSet)
{
payload.WithString("StreamName", m_streamName);
}
if(m_streamARNHasBeenSet)
{
payload.WithString("StreamARN", m_streamARN);
}
if(m_streamStatusHasBeenSet)
{
payload.WithString("StreamStatus", StreamStatusMapper::GetNameForStreamStatus(m_streamStatus));
}
if(m_shardsHasBeenSet)
{
Array<JsonValue> shardsJsonList(m_shards.size());
for(unsigned shardsIndex = 0; shardsIndex < shardsJsonList.GetLength(); ++shardsIndex)
{
shardsJsonList[shardsIndex].AsObject(m_shards[shardsIndex].Jsonize());
}
payload.WithArray("Shards", std::move(shardsJsonList));
}
if(m_hasMoreShardsHasBeenSet)
{
payload.WithBool("HasMoreShards", m_hasMoreShards);
}
if(m_retentionPeriodHoursHasBeenSet)
{
payload.WithInteger("RetentionPeriodHours", m_retentionPeriodHours);
}
if(m_streamCreationTimestampHasBeenSet)
{
payload.WithDouble("StreamCreationTimestamp", m_streamCreationTimestamp.SecondsWithMSPrecision());
}
if(m_enhancedMonitoringHasBeenSet)
{
Array<JsonValue> enhancedMonitoringJsonList(m_enhancedMonitoring.size());
for(unsigned enhancedMonitoringIndex = 0; enhancedMonitoringIndex < enhancedMonitoringJsonList.GetLength(); ++enhancedMonitoringIndex)
{
enhancedMonitoringJsonList[enhancedMonitoringIndex].AsObject(m_enhancedMonitoring[enhancedMonitoringIndex].Jsonize());
}
payload.WithArray("EnhancedMonitoring", std::move(enhancedMonitoringJsonList));
}
return payload;
}
JsonValue Command::Jsonize() const
{
JsonValue payload;
if(m_commandIdHasBeenSet)
{
payload.WithString("CommandId", m_commandId);
}
if(m_documentNameHasBeenSet)
{
payload.WithString("DocumentName", m_documentName);
}
if(m_commentHasBeenSet)
{
payload.WithString("Comment", m_comment);
}
if(m_expiresAfterHasBeenSet)
{
payload.WithDouble("ExpiresAfter", m_expiresAfter.SecondsWithMSPrecision());
}
if(m_parametersHasBeenSet)
{
JsonValue parametersJsonMap;
for(auto& parametersItem : m_parameters)
{
Array<JsonValue> parameterValueListJsonList(parametersItem.second.size());
for(unsigned parameterValueListIndex = 0; parameterValueListIndex < parameterValueListJsonList.GetLength(); ++parameterValueListIndex)
{
parameterValueListJsonList[parameterValueListIndex].AsString(parametersItem.second[parameterValueListIndex]);
}
parametersJsonMap.WithArray(parametersItem.first, std::move(parameterValueListJsonList));
}
payload.WithObject("Parameters", std::move(parametersJsonMap));
}
if(m_instanceIdsHasBeenSet)
{
Array<JsonValue> instanceIdsJsonList(m_instanceIds.size());
for(unsigned instanceIdsIndex = 0; instanceIdsIndex < instanceIdsJsonList.GetLength(); ++instanceIdsIndex)
{
instanceIdsJsonList[instanceIdsIndex].AsString(m_instanceIds[instanceIdsIndex]);
}
payload.WithArray("InstanceIds", std::move(instanceIdsJsonList));
}
if(m_targetsHasBeenSet)
{
Array<JsonValue> targetsJsonList(m_targets.size());
for(unsigned targetsIndex = 0; targetsIndex < targetsJsonList.GetLength(); ++targetsIndex)
{
targetsJsonList[targetsIndex].AsObject(m_targets[targetsIndex].Jsonize());
}
payload.WithArray("Targets", std::move(targetsJsonList));
}
if(m_requestedDateTimeHasBeenSet)
{
payload.WithDouble("RequestedDateTime", m_requestedDateTime.SecondsWithMSPrecision());
}
if(m_statusHasBeenSet)
{
payload.WithString("Status", CommandStatusMapper::GetNameForCommandStatus(m_status));
}
if(m_statusDetailsHasBeenSet)
{
payload.WithString("StatusDetails", m_statusDetails);
}
if(m_outputS3RegionHasBeenSet)
{
payload.WithString("OutputS3Region", m_outputS3Region);
}
if(m_outputS3BucketNameHasBeenSet)
{
payload.WithString("OutputS3BucketName", m_outputS3BucketName);
}
if(m_outputS3KeyPrefixHasBeenSet)
{
payload.WithString("OutputS3KeyPrefix", m_outputS3KeyPrefix);
}
if(m_maxConcurrencyHasBeenSet)
{
payload.WithString("MaxConcurrency", m_maxConcurrency);
}
if(m_maxErrorsHasBeenSet)
{
payload.WithString("MaxErrors", m_maxErrors);
}
if(m_targetCountHasBeenSet)
{
payload.WithInteger("TargetCount", m_targetCount);
}
if(m_completedCountHasBeenSet)
{
payload.WithInteger("CompletedCount", m_completedCount);
}
if(m_errorCountHasBeenSet)
{
payload.WithInteger("ErrorCount", m_errorCount);
}
if(m_serviceRoleHasBeenSet)
{
payload.WithString("ServiceRole", m_serviceRole);
}
if(m_notificationConfigHasBeenSet)
{
payload.WithObject("NotificationConfig", m_notificationConfig.Jsonize());
}
return payload;
}
JsonValue Parameter::Jsonize() const
{
JsonValue payload;
if(m_parameterNameHasBeenSet)
{
payload.WithString("ParameterName", m_parameterName);
}
if(m_parameterTypeHasBeenSet)
{
payload.WithString("ParameterType", ParameterTypeMapper::GetNameForParameterType(m_parameterType));
}
if(m_parameterValueHasBeenSet)
{
payload.WithString("ParameterValue", m_parameterValue);
}
if(m_nodeTypeSpecificValuesHasBeenSet)
{
Array<JsonValue> nodeTypeSpecificValuesJsonList(m_nodeTypeSpecificValues.size());
for(unsigned nodeTypeSpecificValuesIndex = 0; nodeTypeSpecificValuesIndex < nodeTypeSpecificValuesJsonList.GetLength(); ++nodeTypeSpecificValuesIndex)
{
nodeTypeSpecificValuesJsonList[nodeTypeSpecificValuesIndex].AsObject(m_nodeTypeSpecificValues[nodeTypeSpecificValuesIndex].Jsonize());
}
payload.WithArray("NodeTypeSpecificValues", std::move(nodeTypeSpecificValuesJsonList));
}
if(m_descriptionHasBeenSet)
{
payload.WithString("Description", m_description);
}
if(m_sourceHasBeenSet)
{
payload.WithString("Source", m_source);
}
if(m_dataTypeHasBeenSet)
{
payload.WithString("DataType", m_dataType);
}
if(m_allowedValuesHasBeenSet)
{
payload.WithString("AllowedValues", m_allowedValues);
}
if(m_isModifiableHasBeenSet)
{
payload.WithString("IsModifiable", IsModifiableMapper::GetNameForIsModifiable(m_isModifiable));
}
if(m_changeTypeHasBeenSet)
{
payload.WithString("ChangeType", ChangeTypeMapper::GetNameForChangeType(m_changeType));
}
return payload;
}
JsonValue AutomationExecution::Jsonize() const
{
JsonValue payload;
if(m_automationExecutionIdHasBeenSet)
{
payload.WithString("AutomationExecutionId", m_automationExecutionId);
}
if(m_documentNameHasBeenSet)
{
payload.WithString("DocumentName", m_documentName);
}
if(m_documentVersionHasBeenSet)
{
payload.WithString("DocumentVersion", m_documentVersion);
}
if(m_executionStartTimeHasBeenSet)
{
payload.WithDouble("ExecutionStartTime", m_executionStartTime.SecondsWithMSPrecision());
}
if(m_executionEndTimeHasBeenSet)
{
payload.WithDouble("ExecutionEndTime", m_executionEndTime.SecondsWithMSPrecision());
}
if(m_automationExecutionStatusHasBeenSet)
{
payload.WithString("AutomationExecutionStatus", AutomationExecutionStatusMapper::GetNameForAutomationExecutionStatus(m_automationExecutionStatus));
}
if(m_stepExecutionsHasBeenSet)
{
Array<JsonValue> stepExecutionsJsonList(m_stepExecutions.size());
for(unsigned stepExecutionsIndex = 0; stepExecutionsIndex < stepExecutionsJsonList.GetLength(); ++stepExecutionsIndex)
{
stepExecutionsJsonList[stepExecutionsIndex].AsObject(m_stepExecutions[stepExecutionsIndex].Jsonize());
}
payload.WithArray("StepExecutions", std::move(stepExecutionsJsonList));
}
if(m_parametersHasBeenSet)
{
JsonValue parametersJsonMap;
for(auto& parametersItem : m_parameters)
{
Array<JsonValue> automationParameterValueListJsonList(parametersItem.second.size());
for(unsigned automationParameterValueListIndex = 0; automationParameterValueListIndex < automationParameterValueListJsonList.GetLength(); ++automationParameterValueListIndex)
{
automationParameterValueListJsonList[automationParameterValueListIndex].AsString(parametersItem.second[automationParameterValueListIndex]);
}
parametersJsonMap.WithArray(parametersItem.first, std::move(automationParameterValueListJsonList));
}
payload.WithObject("Parameters", std::move(parametersJsonMap));
}
if(m_outputsHasBeenSet)
{
JsonValue outputsJsonMap;
for(auto& outputsItem : m_outputs)
{
Array<JsonValue> automationParameterValueListJsonList(outputsItem.second.size());
for(unsigned automationParameterValueListIndex = 0; automationParameterValueListIndex < automationParameterValueListJsonList.GetLength(); ++automationParameterValueListIndex)
{
automationParameterValueListJsonList[automationParameterValueListIndex].AsString(outputsItem.second[automationParameterValueListIndex]);
}
outputsJsonMap.WithArray(outputsItem.first, std::move(automationParameterValueListJsonList));
}
payload.WithObject("Outputs", std::move(outputsJsonMap));
}
if(m_failureMessageHasBeenSet)
{
payload.WithString("FailureMessage", m_failureMessage);
}
return payload;
}
JsonValue Integration::Jsonize() const
{
JsonValue payload;
if(m_typeHasBeenSet)
{
payload.WithString("type", IntegrationTypeMapper::GetNameForIntegrationType(m_type));
}
if(m_httpMethodHasBeenSet)
{
payload.WithString("httpMethod", m_httpMethod);
}
if(m_uriHasBeenSet)
{
payload.WithString("uri", m_uri);
}
if(m_credentialsHasBeenSet)
{
payload.WithString("credentials", m_credentials);
}
if(m_requestParametersHasBeenSet)
{
JsonValue requestParametersJsonMap;
for(auto& requestParametersItem : m_requestParameters)
{
requestParametersJsonMap.WithString(requestParametersItem.first, requestParametersItem.second);
}
payload.WithObject("requestParameters", std::move(requestParametersJsonMap));
}
if(m_requestTemplatesHasBeenSet)
{
JsonValue requestTemplatesJsonMap;
for(auto& requestTemplatesItem : m_requestTemplates)
{
requestTemplatesJsonMap.WithString(requestTemplatesItem.first, requestTemplatesItem.second);
}
payload.WithObject("requestTemplates", std::move(requestTemplatesJsonMap));
}
if(m_passthroughBehaviorHasBeenSet)
{
payload.WithString("passthroughBehavior", m_passthroughBehavior);
}
if(m_cacheNamespaceHasBeenSet)
{
payload.WithString("cacheNamespace", m_cacheNamespace);
}
if(m_cacheKeyParametersHasBeenSet)
{
Array<JsonValue> cacheKeyParametersJsonList(m_cacheKeyParameters.size());
for(unsigned cacheKeyParametersIndex = 0; cacheKeyParametersIndex < cacheKeyParametersJsonList.GetLength(); ++cacheKeyParametersIndex)
{
cacheKeyParametersJsonList[cacheKeyParametersIndex].AsString(m_cacheKeyParameters[cacheKeyParametersIndex]);
}
payload.WithArray("cacheKeyParameters", std::move(cacheKeyParametersJsonList));
}
if(m_integrationResponsesHasBeenSet)
{
JsonValue integrationResponsesJsonMap;
for(auto& integrationResponsesItem : m_integrationResponses)
{
integrationResponsesJsonMap.WithObject(integrationResponsesItem.first, integrationResponsesItem.second.Jsonize());
}
payload.WithObject("integrationResponses", std::move(integrationResponsesJsonMap));
}
return payload;
}
JsonValue InstanceGroup::Jsonize() const
{
JsonValue payload;
if(m_idHasBeenSet)
{
payload.WithString("Id", m_id);
}
if(m_nameHasBeenSet)
{
payload.WithString("Name", m_name);
}
if(m_marketHasBeenSet)
{
payload.WithString("Market", MarketTypeMapper::GetNameForMarketType(m_market));
}
if(m_instanceGroupTypeHasBeenSet)
{
payload.WithString("InstanceGroupType", InstanceGroupTypeMapper::GetNameForInstanceGroupType(m_instanceGroupType));
}
if(m_bidPriceHasBeenSet)
{
payload.WithString("BidPrice", m_bidPrice);
}
if(m_instanceTypeHasBeenSet)
{
payload.WithString("InstanceType", m_instanceType);
}
if(m_requestedInstanceCountHasBeenSet)
{
payload.WithInteger("RequestedInstanceCount", m_requestedInstanceCount);
}
if(m_runningInstanceCountHasBeenSet)
{
payload.WithInteger("RunningInstanceCount", m_runningInstanceCount);
}
if(m_statusHasBeenSet)
{
payload.WithObject("Status", m_status.Jsonize());
}
if(m_configurationsHasBeenSet)
{
Array<JsonValue> configurationsJsonList(m_configurations.size());
for(unsigned configurationsIndex = 0; configurationsIndex < configurationsJsonList.GetLength(); ++configurationsIndex)
{
configurationsJsonList[configurationsIndex].AsObject(m_configurations[configurationsIndex].Jsonize());
}
payload.WithArray("Configurations", std::move(configurationsJsonList));
}
return std::move(payload);
}
JsonValue JobFlowDetail::Jsonize() const
{
JsonValue payload;
if(m_jobFlowIdHasBeenSet)
{
payload.WithString("JobFlowId", m_jobFlowId);
}
if(m_nameHasBeenSet)
{
payload.WithString("Name", m_name);
}
if(m_logUriHasBeenSet)
{
payload.WithString("LogUri", m_logUri);
}
if(m_amiVersionHasBeenSet)
{
payload.WithString("AmiVersion", m_amiVersion);
}
if(m_executionStatusDetailHasBeenSet)
{
payload.WithObject("ExecutionStatusDetail", m_executionStatusDetail.Jsonize());
}
if(m_instancesHasBeenSet)
{
payload.WithObject("Instances", m_instances.Jsonize());
}
if(m_stepsHasBeenSet)
{
Array<JsonValue> stepsJsonList(m_steps.size());
for(unsigned stepsIndex = 0; stepsIndex < stepsJsonList.GetLength(); ++stepsIndex)
{
stepsJsonList[stepsIndex].AsObject(m_steps[stepsIndex].Jsonize());
}
payload.WithArray("Steps", std::move(stepsJsonList));
}
if(m_bootstrapActionsHasBeenSet)
{
Array<JsonValue> bootstrapActionsJsonList(m_bootstrapActions.size());
for(unsigned bootstrapActionsIndex = 0; bootstrapActionsIndex < bootstrapActionsJsonList.GetLength(); ++bootstrapActionsIndex)
{
bootstrapActionsJsonList[bootstrapActionsIndex].AsObject(m_bootstrapActions[bootstrapActionsIndex].Jsonize());
}
payload.WithArray("BootstrapActions", std::move(bootstrapActionsJsonList));
}
if(m_supportedProductsHasBeenSet)
{
Array<JsonValue> supportedProductsJsonList(m_supportedProducts.size());
for(unsigned supportedProductsIndex = 0; supportedProductsIndex < supportedProductsJsonList.GetLength(); ++supportedProductsIndex)
{
supportedProductsJsonList[supportedProductsIndex].AsString(m_supportedProducts[supportedProductsIndex]);
}
payload.WithArray("SupportedProducts", std::move(supportedProductsJsonList));
}
if(m_visibleToAllUsersHasBeenSet)
{
payload.WithBool("VisibleToAllUsers", m_visibleToAllUsers);
}
if(m_jobFlowRoleHasBeenSet)
{
payload.WithString("JobFlowRole", m_jobFlowRole);
}
if(m_serviceRoleHasBeenSet)
{
payload.WithString("ServiceRole", m_serviceRole);
}
if(m_autoScalingRoleHasBeenSet)
{
payload.WithString("AutoScalingRole", m_autoScalingRole);
}
if(m_scaleDownBehaviorHasBeenSet)
{
payload.WithString("ScaleDownBehavior", ScaleDownBehaviorMapper::GetNameForScaleDownBehavior(m_scaleDownBehavior));
}
return payload;
}
Aws::String SearchProductsAsAdminRequest::SerializePayload() const
{
JsonValue payload;
if(m_acceptLanguageHasBeenSet)
{
payload.WithString("AcceptLanguage", m_acceptLanguage);
}
if(m_portfolioIdHasBeenSet)
{
payload.WithString("PortfolioId", m_portfolioId);
}
if(m_filtersHasBeenSet)
{
JsonValue filtersJsonMap;
for(auto& filtersItem : m_filters)
{
Array<JsonValue> productViewFilterValuesJsonList(filtersItem.second.size());
for(unsigned productViewFilterValuesIndex = 0; productViewFilterValuesIndex < productViewFilterValuesJsonList.GetLength(); ++productViewFilterValuesIndex)
{
productViewFilterValuesJsonList[productViewFilterValuesIndex].AsString(filtersItem.second[productViewFilterValuesIndex]);
}
filtersJsonMap.WithArray(ProductViewFilterByMapper::GetNameForProductViewFilterBy(filtersItem.first), std::move(productViewFilterValuesJsonList));
}
payload.WithObject("Filters", std::move(filtersJsonMap));
}
if(m_sortByHasBeenSet)
{
payload.WithString("SortBy", ProductViewSortByMapper::GetNameForProductViewSortBy(m_sortBy));
}
if(m_sortOrderHasBeenSet)
{
payload.WithString("SortOrder", SortOrderMapper::GetNameForSortOrder(m_sortOrder));
}
if(m_pageTokenHasBeenSet)
{
payload.WithString("PageToken", m_pageToken);
}
if(m_pageSizeHasBeenSet)
{
payload.WithInteger("PageSize", m_pageSize);
}
if(m_productSourceHasBeenSet)
{
payload.WithString("ProductSource", ProductSourceMapper::GetNameForProductSource(m_productSource));
}
return payload.WriteReadable();
}
JsonValue APNSMessage::Jsonize() const
{
JsonValue payload;
if(m_actionHasBeenSet)
{
payload.WithString("Action", ActionMapper::GetNameForAction(m_action));
}
if(m_badgeHasBeenSet)
{
payload.WithInteger("Badge", m_badge);
}
if(m_bodyHasBeenSet)
{
payload.WithString("Body", m_body);
}
if(m_categoryHasBeenSet)
{
payload.WithString("Category", m_category);
}
if(m_dataHasBeenSet)
{
JsonValue dataJsonMap;
for(auto& dataItem : m_data)
{
dataJsonMap.WithString(dataItem.first, dataItem.second);
}
payload.WithObject("Data", std::move(dataJsonMap));
}
if(m_mediaUrlHasBeenSet)
{
payload.WithString("MediaUrl", m_mediaUrl);
}
if(m_rawContentHasBeenSet)
{
payload.WithString("RawContent", m_rawContent);
}
if(m_silentPushHasBeenSet)
{
payload.WithBool("SilentPush", m_silentPush);
}
if(m_soundHasBeenSet)
{
payload.WithString("Sound", m_sound);
}
if(m_substitutionsHasBeenSet)
{
JsonValue substitutionsJsonMap;
for(auto& substitutionsItem : m_substitutions)
{
Array<JsonValue> listOf__stringJsonList(substitutionsItem.second.size());
for(unsigned listOf__stringIndex = 0; listOf__stringIndex < listOf__stringJsonList.GetLength(); ++listOf__stringIndex)
{
listOf__stringJsonList[listOf__stringIndex].AsString(substitutionsItem.second[listOf__stringIndex]);
}
substitutionsJsonMap.WithArray(substitutionsItem.first, std::move(listOf__stringJsonList));
}
payload.WithObject("Substitutions", std::move(substitutionsJsonMap));
}
if(m_threadIdHasBeenSet)
{
payload.WithString("ThreadId", m_threadId);
}
if(m_titleHasBeenSet)
{
payload.WithString("Title", m_title);
}
if(m_urlHasBeenSet)
{
payload.WithString("Url", m_url);
}
return payload;
}
JsonValue DeploymentGroupInfo::Jsonize() const
{
JsonValue payload;
if(m_applicationNameHasBeenSet)
{
payload.WithString("applicationName", m_applicationName);
}
if(m_deploymentGroupIdHasBeenSet)
{
payload.WithString("deploymentGroupId", m_deploymentGroupId);
}
if(m_deploymentGroupNameHasBeenSet)
{
payload.WithString("deploymentGroupName", m_deploymentGroupName);
}
if(m_deploymentConfigNameHasBeenSet)
{
payload.WithString("deploymentConfigName", m_deploymentConfigName);
}
if(m_ec2TagFiltersHasBeenSet)
{
Array<JsonValue> ec2TagFiltersJsonList(m_ec2TagFilters.size());
for(unsigned ec2TagFiltersIndex = 0; ec2TagFiltersIndex < ec2TagFiltersJsonList.GetLength(); ++ec2TagFiltersIndex)
{
ec2TagFiltersJsonList[ec2TagFiltersIndex].AsObject(m_ec2TagFilters[ec2TagFiltersIndex].Jsonize());
}
payload.WithArray("ec2TagFilters", std::move(ec2TagFiltersJsonList));
}
if(m_onPremisesInstanceTagFiltersHasBeenSet)
{
Array<JsonValue> onPremisesInstanceTagFiltersJsonList(m_onPremisesInstanceTagFilters.size());
for(unsigned onPremisesInstanceTagFiltersIndex = 0; onPremisesInstanceTagFiltersIndex < onPremisesInstanceTagFiltersJsonList.GetLength(); ++onPremisesInstanceTagFiltersIndex)
{
onPremisesInstanceTagFiltersJsonList[onPremisesInstanceTagFiltersIndex].AsObject(m_onPremisesInstanceTagFilters[onPremisesInstanceTagFiltersIndex].Jsonize());
}
payload.WithArray("onPremisesInstanceTagFilters", std::move(onPremisesInstanceTagFiltersJsonList));
}
if(m_autoScalingGroupsHasBeenSet)
{
Array<JsonValue> autoScalingGroupsJsonList(m_autoScalingGroups.size());
for(unsigned autoScalingGroupsIndex = 0; autoScalingGroupsIndex < autoScalingGroupsJsonList.GetLength(); ++autoScalingGroupsIndex)
{
autoScalingGroupsJsonList[autoScalingGroupsIndex].AsObject(m_autoScalingGroups[autoScalingGroupsIndex].Jsonize());
}
payload.WithArray("autoScalingGroups", std::move(autoScalingGroupsJsonList));
}
if(m_serviceRoleArnHasBeenSet)
{
payload.WithString("serviceRoleArn", m_serviceRoleArn);
}
if(m_targetRevisionHasBeenSet)
{
payload.WithObject("targetRevision", m_targetRevision.Jsonize());
}
if(m_triggerConfigurationsHasBeenSet)
{
Array<JsonValue> triggerConfigurationsJsonList(m_triggerConfigurations.size());
for(unsigned triggerConfigurationsIndex = 0; triggerConfigurationsIndex < triggerConfigurationsJsonList.GetLength(); ++triggerConfigurationsIndex)
{
triggerConfigurationsJsonList[triggerConfigurationsIndex].AsObject(m_triggerConfigurations[triggerConfigurationsIndex].Jsonize());
}
payload.WithArray("triggerConfigurations", std::move(triggerConfigurationsJsonList));
}
return payload;
}
JsonValue WorkspaceDirectory::Jsonize() const
{
JsonValue payload;
if(m_directoryIdHasBeenSet)
{
payload.WithString("DirectoryId", m_directoryId);
}
if(m_aliasHasBeenSet)
{
payload.WithString("Alias", m_alias);
}
if(m_directoryNameHasBeenSet)
{
payload.WithString("DirectoryName", m_directoryName);
}
if(m_registrationCodeHasBeenSet)
{
payload.WithString("RegistrationCode", m_registrationCode);
}
if(m_subnetIdsHasBeenSet)
{
Array<JsonValue> subnetIdsJsonList(m_subnetIds.size());
for(unsigned subnetIdsIndex = 0; subnetIdsIndex < subnetIdsJsonList.GetLength(); ++subnetIdsIndex)
{
subnetIdsJsonList[subnetIdsIndex].AsString(m_subnetIds[subnetIdsIndex]);
}
payload.WithArray("SubnetIds", std::move(subnetIdsJsonList));
}
if(m_dnsIpAddressesHasBeenSet)
{
Array<JsonValue> dnsIpAddressesJsonList(m_dnsIpAddresses.size());
for(unsigned dnsIpAddressesIndex = 0; dnsIpAddressesIndex < dnsIpAddressesJsonList.GetLength(); ++dnsIpAddressesIndex)
{
dnsIpAddressesJsonList[dnsIpAddressesIndex].AsString(m_dnsIpAddresses[dnsIpAddressesIndex]);
}
payload.WithArray("DnsIpAddresses", std::move(dnsIpAddressesJsonList));
}
if(m_customerUserNameHasBeenSet)
{
payload.WithString("CustomerUserName", m_customerUserName);
}
if(m_iamRoleIdHasBeenSet)
{
payload.WithString("IamRoleId", m_iamRoleId);
}
if(m_directoryTypeHasBeenSet)
{
payload.WithString("DirectoryType", WorkspaceDirectoryTypeMapper::GetNameForWorkspaceDirectoryType(m_directoryType));
}
if(m_workspaceSecurityGroupIdHasBeenSet)
{
payload.WithString("WorkspaceSecurityGroupId", m_workspaceSecurityGroupId);
}
if(m_stateHasBeenSet)
{
payload.WithString("State", WorkspaceDirectoryStateMapper::GetNameForWorkspaceDirectoryState(m_state));
}
if(m_workspaceCreationPropertiesHasBeenSet)
{
payload.WithObject("WorkspaceCreationProperties", m_workspaceCreationProperties.Jsonize());
}
return payload;
}
Aws::String CreateLayerRequest::SerializePayload() const
{
JsonValue payload;
if(m_stackIdHasBeenSet)
{
payload.WithString("StackId", m_stackId);
}
if(m_typeHasBeenSet)
{
payload.WithString("Type", LayerTypeMapper::GetNameForLayerType(m_type));
}
if(m_nameHasBeenSet)
{
payload.WithString("Name", m_name);
}
if(m_shortnameHasBeenSet)
{
payload.WithString("Shortname", m_shortname);
}
if(m_attributesHasBeenSet)
{
JsonValue attributesJsonMap;
for(auto& attributesItem : m_attributes)
{
attributesJsonMap.WithString(LayerAttributesKeysMapper::GetNameForLayerAttributesKeys(attributesItem.first), attributesItem.second);
}
payload.WithObject("Attributes", std::move(attributesJsonMap));
}
if(m_customInstanceProfileArnHasBeenSet)
{
payload.WithString("CustomInstanceProfileArn", m_customInstanceProfileArn);
}
if(m_customJsonHasBeenSet)
{
payload.WithString("CustomJson", m_customJson);
}
if(m_customSecurityGroupIdsHasBeenSet)
{
Array<JsonValue> customSecurityGroupIdsJsonList(m_customSecurityGroupIds.size());
for(unsigned customSecurityGroupIdsIndex = 0; customSecurityGroupIdsIndex < customSecurityGroupIdsJsonList.GetLength(); ++customSecurityGroupIdsIndex)
{
customSecurityGroupIdsJsonList[customSecurityGroupIdsIndex].AsString(m_customSecurityGroupIds[customSecurityGroupIdsIndex]);
}
payload.WithArray("CustomSecurityGroupIds", std::move(customSecurityGroupIdsJsonList));
}
if(m_packagesHasBeenSet)
{
Array<JsonValue> packagesJsonList(m_packages.size());
for(unsigned packagesIndex = 0; packagesIndex < packagesJsonList.GetLength(); ++packagesIndex)
{
packagesJsonList[packagesIndex].AsString(m_packages[packagesIndex]);
}
payload.WithArray("Packages", std::move(packagesJsonList));
}
if(m_volumeConfigurationsHasBeenSet)
{
Array<JsonValue> volumeConfigurationsJsonList(m_volumeConfigurations.size());
for(unsigned volumeConfigurationsIndex = 0; volumeConfigurationsIndex < volumeConfigurationsJsonList.GetLength(); ++volumeConfigurationsIndex)
{
volumeConfigurationsJsonList[volumeConfigurationsIndex].AsObject(m_volumeConfigurations[volumeConfigurationsIndex].Jsonize());
}
payload.WithArray("VolumeConfigurations", std::move(volumeConfigurationsJsonList));
}
if(m_enableAutoHealingHasBeenSet)
{
payload.WithBool("EnableAutoHealing", m_enableAutoHealing);
}
if(m_autoAssignElasticIpsHasBeenSet)
{
payload.WithBool("AutoAssignElasticIps", m_autoAssignElasticIps);
}
if(m_autoAssignPublicIpsHasBeenSet)
{
payload.WithBool("AutoAssignPublicIps", m_autoAssignPublicIps);
}
if(m_customRecipesHasBeenSet)
{
payload.WithObject("CustomRecipes", m_customRecipes.Jsonize());
}
if(m_installUpdatesOnBootHasBeenSet)
{
payload.WithBool("InstallUpdatesOnBoot", m_installUpdatesOnBoot);
}
if(m_useEbsOptimizedInstancesHasBeenSet)
{
payload.WithBool("UseEbsOptimizedInstances", m_useEbsOptimizedInstances);
}
if(m_lifecycleEventConfigurationHasBeenSet)
{
payload.WithObject("LifecycleEventConfiguration", m_lifecycleEventConfiguration.Jsonize());
}
return payload.WriteReadable();
}
Aws::String CreateServiceRequest::SerializePayload() const
{
JsonValue payload;
if(m_clusterHasBeenSet)
{
payload.WithString("cluster", m_cluster);
}
if(m_serviceNameHasBeenSet)
{
payload.WithString("serviceName", m_serviceName);
}
if(m_taskDefinitionHasBeenSet)
{
payload.WithString("taskDefinition", m_taskDefinition);
}
if(m_loadBalancersHasBeenSet)
{
Array<JsonValue> loadBalancersJsonList(m_loadBalancers.size());
for(unsigned loadBalancersIndex = 0; loadBalancersIndex < loadBalancersJsonList.GetLength(); ++loadBalancersIndex)
{
loadBalancersJsonList[loadBalancersIndex].AsObject(m_loadBalancers[loadBalancersIndex].Jsonize());
}
payload.WithArray("loadBalancers", std::move(loadBalancersJsonList));
}
if(m_serviceRegistriesHasBeenSet)
{
Array<JsonValue> serviceRegistriesJsonList(m_serviceRegistries.size());
for(unsigned serviceRegistriesIndex = 0; serviceRegistriesIndex < serviceRegistriesJsonList.GetLength(); ++serviceRegistriesIndex)
{
serviceRegistriesJsonList[serviceRegistriesIndex].AsObject(m_serviceRegistries[serviceRegistriesIndex].Jsonize());
}
payload.WithArray("serviceRegistries", std::move(serviceRegistriesJsonList));
}
if(m_desiredCountHasBeenSet)
{
payload.WithInteger("desiredCount", m_desiredCount);
}
if(m_clientTokenHasBeenSet)
{
payload.WithString("clientToken", m_clientToken);
}
if(m_launchTypeHasBeenSet)
{
payload.WithString("launchType", LaunchTypeMapper::GetNameForLaunchType(m_launchType));
}
if(m_platformVersionHasBeenSet)
{
payload.WithString("platformVersion", m_platformVersion);
}
if(m_roleHasBeenSet)
{
payload.WithString("role", m_role);
}
if(m_deploymentConfigurationHasBeenSet)
{
payload.WithObject("deploymentConfiguration", m_deploymentConfiguration.Jsonize());
}
if(m_placementConstraintsHasBeenSet)
{
Array<JsonValue> placementConstraintsJsonList(m_placementConstraints.size());
for(unsigned placementConstraintsIndex = 0; placementConstraintsIndex < placementConstraintsJsonList.GetLength(); ++placementConstraintsIndex)
{
placementConstraintsJsonList[placementConstraintsIndex].AsObject(m_placementConstraints[placementConstraintsIndex].Jsonize());
}
payload.WithArray("placementConstraints", std::move(placementConstraintsJsonList));
}
if(m_placementStrategyHasBeenSet)
{
Array<JsonValue> placementStrategyJsonList(m_placementStrategy.size());
for(unsigned placementStrategyIndex = 0; placementStrategyIndex < placementStrategyJsonList.GetLength(); ++placementStrategyIndex)
{
placementStrategyJsonList[placementStrategyIndex].AsObject(m_placementStrategy[placementStrategyIndex].Jsonize());
}
payload.WithArray("placementStrategy", std::move(placementStrategyJsonList));
}
if(m_networkConfigurationHasBeenSet)
{
payload.WithObject("networkConfiguration", m_networkConfiguration.Jsonize());
}
if(m_healthCheckGracePeriodSecondsHasBeenSet)
{
payload.WithInteger("healthCheckGracePeriodSeconds", m_healthCheckGracePeriodSeconds);
}
if(m_schedulingStrategyHasBeenSet)
{
payload.WithString("schedulingStrategy", SchedulingStrategyMapper::GetNameForSchedulingStrategy(m_schedulingStrategy));
}
return payload.View().WriteReadable();
}
Aws::String CreateAppRequest::SerializePayload() const
{
JsonValue payload;
if(m_nameHasBeenSet)
{
payload.WithString("name", m_name);
}
if(m_descriptionHasBeenSet)
{
payload.WithString("description", m_description);
}
if(m_repositoryHasBeenSet)
{
payload.WithString("repository", m_repository);
}
if(m_platformHasBeenSet)
{
payload.WithString("platform", PlatformMapper::GetNameForPlatform(m_platform));
}
if(m_iamServiceRoleArnHasBeenSet)
{
payload.WithString("iamServiceRoleArn", m_iamServiceRoleArn);
}
if(m_oauthTokenHasBeenSet)
{
payload.WithString("oauthToken", m_oauthToken);
}
if(m_environmentVariablesHasBeenSet)
{
JsonValue environmentVariablesJsonMap;
for(auto& environmentVariablesItem : m_environmentVariables)
{
environmentVariablesJsonMap.WithString(environmentVariablesItem.first, environmentVariablesItem.second);
}
payload.WithObject("environmentVariables", std::move(environmentVariablesJsonMap));
}
if(m_enableBranchAutoBuildHasBeenSet)
{
payload.WithBool("enableBranchAutoBuild", m_enableBranchAutoBuild);
}
if(m_enableBasicAuthHasBeenSet)
{
payload.WithBool("enableBasicAuth", m_enableBasicAuth);
}
if(m_basicAuthCredentialsHasBeenSet)
{
payload.WithString("basicAuthCredentials", m_basicAuthCredentials);
}
if(m_customRulesHasBeenSet)
{
Array<JsonValue> customRulesJsonList(m_customRules.size());
for(unsigned customRulesIndex = 0; customRulesIndex < customRulesJsonList.GetLength(); ++customRulesIndex)
{
customRulesJsonList[customRulesIndex].AsObject(m_customRules[customRulesIndex].Jsonize());
}
payload.WithArray("customRules", std::move(customRulesJsonList));
}
if(m_tagsHasBeenSet)
{
JsonValue tagsJsonMap;
for(auto& tagsItem : m_tags)
{
tagsJsonMap.WithString(tagsItem.first, tagsItem.second);
}
payload.WithObject("tags", std::move(tagsJsonMap));
}
if(m_buildSpecHasBeenSet)
{
payload.WithString("buildSpec", m_buildSpec);
}
return payload.View().WriteReadable();
}
Aws::String DescribeCasesRequest::SerializePayload() const
{
JsonValue payload;
if(m_caseIdListHasBeenSet)
{
Array<JsonValue> caseIdListJsonList(m_caseIdList.size());
for(unsigned caseIdListIndex = 0; caseIdListIndex < caseIdListJsonList.GetLength(); ++caseIdListIndex)
{
caseIdListJsonList[caseIdListIndex].AsString(m_caseIdList[caseIdListIndex]);
}
payload.WithArray("caseIdList", std::move(caseIdListJsonList));
}
if(m_displayIdHasBeenSet)
{
payload.WithString("displayId", m_displayId);
}
if(m_afterTimeHasBeenSet)
{
payload.WithString("afterTime", m_afterTime);
}
if(m_beforeTimeHasBeenSet)
{
payload.WithString("beforeTime", m_beforeTime);
}
if(m_includeResolvedCasesHasBeenSet)
{
payload.WithBool("includeResolvedCases", m_includeResolvedCases);
}
if(m_nextTokenHasBeenSet)
{
payload.WithString("nextToken", m_nextToken);
}
if(m_maxResultsHasBeenSet)
{
payload.WithInteger("maxResults", m_maxResults);
}
if(m_languageHasBeenSet)
{
payload.WithString("language", m_language);
}
if(m_includeCommunicationsHasBeenSet)
{
payload.WithBool("includeCommunications", m_includeCommunications);
}
return payload.WriteReadable();
}
Aws::String CreateClusterRequest::SerializePayload() const
{
JsonValue payload;
if(m_clusterNameHasBeenSet)
{
payload.WithString("ClusterName", m_clusterName);
}
if(m_nodeTypeHasBeenSet)
{
payload.WithString("NodeType", m_nodeType);
}
if(m_descriptionHasBeenSet)
{
payload.WithString("Description", m_description);
}
if(m_replicationFactorHasBeenSet)
{
payload.WithInteger("ReplicationFactor", m_replicationFactor);
}
if(m_availabilityZonesHasBeenSet)
{
Array<JsonValue> availabilityZonesJsonList(m_availabilityZones.size());
for(unsigned availabilityZonesIndex = 0; availabilityZonesIndex < availabilityZonesJsonList.GetLength(); ++availabilityZonesIndex)
{
availabilityZonesJsonList[availabilityZonesIndex].AsString(m_availabilityZones[availabilityZonesIndex]);
}
payload.WithArray("AvailabilityZones", std::move(availabilityZonesJsonList));
}
if(m_subnetGroupNameHasBeenSet)
{
payload.WithString("SubnetGroupName", m_subnetGroupName);
}
if(m_securityGroupIdsHasBeenSet)
{
Array<JsonValue> securityGroupIdsJsonList(m_securityGroupIds.size());
for(unsigned securityGroupIdsIndex = 0; securityGroupIdsIndex < securityGroupIdsJsonList.GetLength(); ++securityGroupIdsIndex)
{
securityGroupIdsJsonList[securityGroupIdsIndex].AsString(m_securityGroupIds[securityGroupIdsIndex]);
}
payload.WithArray("SecurityGroupIds", std::move(securityGroupIdsJsonList));
}
if(m_preferredMaintenanceWindowHasBeenSet)
{
payload.WithString("PreferredMaintenanceWindow", m_preferredMaintenanceWindow);
}
if(m_notificationTopicArnHasBeenSet)
{
payload.WithString("NotificationTopicArn", m_notificationTopicArn);
}
if(m_iamRoleArnHasBeenSet)
{
payload.WithString("IamRoleArn", m_iamRoleArn);
}
if(m_parameterGroupNameHasBeenSet)
{
payload.WithString("ParameterGroupName", m_parameterGroupName);
}
if(m_tagsHasBeenSet)
{
Array<JsonValue> tagsJsonList(m_tags.size());
for(unsigned tagsIndex = 0; tagsIndex < tagsJsonList.GetLength(); ++tagsIndex)
{
tagsJsonList[tagsIndex].AsObject(m_tags[tagsIndex].Jsonize());
}
payload.WithArray("Tags", std::move(tagsJsonList));
}
if(m_sSESpecificationHasBeenSet)
{
payload.WithObject("SSESpecification", m_sSESpecification.Jsonize());
}
return payload.View().WriteReadable();
}
JsonValue ContainerDefinition::Jsonize() const
{
JsonValue payload;
if(m_nameHasBeenSet)
{
payload.WithString("name", m_name);
}
if(m_imageHasBeenSet)
{
payload.WithString("image", m_image);
}
if(m_cpuHasBeenSet)
{
payload.WithInteger("cpu", m_cpu);
}
if(m_memoryHasBeenSet)
{
payload.WithInteger("memory", m_memory);
}
if(m_memoryReservationHasBeenSet)
{
payload.WithInteger("memoryReservation", m_memoryReservation);
}
if(m_linksHasBeenSet)
{
Array<JsonValue> linksJsonList(m_links.size());
for(unsigned linksIndex = 0; linksIndex < linksJsonList.GetLength(); ++linksIndex)
{
linksJsonList[linksIndex].AsString(m_links[linksIndex]);
}
payload.WithArray("links", std::move(linksJsonList));
}
if(m_portMappingsHasBeenSet)
{
Array<JsonValue> portMappingsJsonList(m_portMappings.size());
for(unsigned portMappingsIndex = 0; portMappingsIndex < portMappingsJsonList.GetLength(); ++portMappingsIndex)
{
portMappingsJsonList[portMappingsIndex].AsObject(m_portMappings[portMappingsIndex].Jsonize());
}
payload.WithArray("portMappings", std::move(portMappingsJsonList));
}
if(m_essentialHasBeenSet)
{
payload.WithBool("essential", m_essential);
}
if(m_entryPointHasBeenSet)
{
Array<JsonValue> entryPointJsonList(m_entryPoint.size());
for(unsigned entryPointIndex = 0; entryPointIndex < entryPointJsonList.GetLength(); ++entryPointIndex)
{
entryPointJsonList[entryPointIndex].AsString(m_entryPoint[entryPointIndex]);
}
payload.WithArray("entryPoint", std::move(entryPointJsonList));
}
if(m_commandHasBeenSet)
{
Array<JsonValue> commandJsonList(m_command.size());
for(unsigned commandIndex = 0; commandIndex < commandJsonList.GetLength(); ++commandIndex)
{
commandJsonList[commandIndex].AsString(m_command[commandIndex]);
}
payload.WithArray("command", std::move(commandJsonList));
}
if(m_environmentHasBeenSet)
{
Array<JsonValue> environmentJsonList(m_environment.size());
for(unsigned environmentIndex = 0; environmentIndex < environmentJsonList.GetLength(); ++environmentIndex)
{
environmentJsonList[environmentIndex].AsObject(m_environment[environmentIndex].Jsonize());
}
payload.WithArray("environment", std::move(environmentJsonList));
}
if(m_mountPointsHasBeenSet)
{
Array<JsonValue> mountPointsJsonList(m_mountPoints.size());
for(unsigned mountPointsIndex = 0; mountPointsIndex < mountPointsJsonList.GetLength(); ++mountPointsIndex)
{
mountPointsJsonList[mountPointsIndex].AsObject(m_mountPoints[mountPointsIndex].Jsonize());
}
payload.WithArray("mountPoints", std::move(mountPointsJsonList));
}
if(m_volumesFromHasBeenSet)
{
Array<JsonValue> volumesFromJsonList(m_volumesFrom.size());
for(unsigned volumesFromIndex = 0; volumesFromIndex < volumesFromJsonList.GetLength(); ++volumesFromIndex)
{
volumesFromJsonList[volumesFromIndex].AsObject(m_volumesFrom[volumesFromIndex].Jsonize());
}
payload.WithArray("volumesFrom", std::move(volumesFromJsonList));
}
if(m_hostnameHasBeenSet)
{
payload.WithString("hostname", m_hostname);
}
if(m_userHasBeenSet)
{
payload.WithString("user", m_user);
}
if(m_workingDirectoryHasBeenSet)
{
payload.WithString("workingDirectory", m_workingDirectory);
}
if(m_disableNetworkingHasBeenSet)
{
payload.WithBool("disableNetworking", m_disableNetworking);
}
if(m_privilegedHasBeenSet)
{
payload.WithBool("privileged", m_privileged);
}
if(m_readonlyRootFilesystemHasBeenSet)
{
payload.WithBool("readonlyRootFilesystem", m_readonlyRootFilesystem);
}
if(m_dnsServersHasBeenSet)
{
Array<JsonValue> dnsServersJsonList(m_dnsServers.size());
for(unsigned dnsServersIndex = 0; dnsServersIndex < dnsServersJsonList.GetLength(); ++dnsServersIndex)
{
dnsServersJsonList[dnsServersIndex].AsString(m_dnsServers[dnsServersIndex]);
}
payload.WithArray("dnsServers", std::move(dnsServersJsonList));
}
if(m_dnsSearchDomainsHasBeenSet)
{
Array<JsonValue> dnsSearchDomainsJsonList(m_dnsSearchDomains.size());
for(unsigned dnsSearchDomainsIndex = 0; dnsSearchDomainsIndex < dnsSearchDomainsJsonList.GetLength(); ++dnsSearchDomainsIndex)
{
dnsSearchDomainsJsonList[dnsSearchDomainsIndex].AsString(m_dnsSearchDomains[dnsSearchDomainsIndex]);
}
payload.WithArray("dnsSearchDomains", std::move(dnsSearchDomainsJsonList));
}
if(m_extraHostsHasBeenSet)
{
Array<JsonValue> extraHostsJsonList(m_extraHosts.size());
for(unsigned extraHostsIndex = 0; extraHostsIndex < extraHostsJsonList.GetLength(); ++extraHostsIndex)
{
extraHostsJsonList[extraHostsIndex].AsObject(m_extraHosts[extraHostsIndex].Jsonize());
}
payload.WithArray("extraHosts", std::move(extraHostsJsonList));
}
if(m_dockerSecurityOptionsHasBeenSet)
{
Array<JsonValue> dockerSecurityOptionsJsonList(m_dockerSecurityOptions.size());
for(unsigned dockerSecurityOptionsIndex = 0; dockerSecurityOptionsIndex < dockerSecurityOptionsJsonList.GetLength(); ++dockerSecurityOptionsIndex)
{
dockerSecurityOptionsJsonList[dockerSecurityOptionsIndex].AsString(m_dockerSecurityOptions[dockerSecurityOptionsIndex]);
}
payload.WithArray("dockerSecurityOptions", std::move(dockerSecurityOptionsJsonList));
}
if(m_dockerLabelsHasBeenSet)
{
JsonValue dockerLabelsJsonMap;
for(auto& dockerLabelsItem : m_dockerLabels)
{
dockerLabelsJsonMap.WithString(dockerLabelsItem.first, dockerLabelsItem.second);
}
payload.WithObject("dockerLabels", std::move(dockerLabelsJsonMap));
}
if(m_ulimitsHasBeenSet)
{
Array<JsonValue> ulimitsJsonList(m_ulimits.size());
for(unsigned ulimitsIndex = 0; ulimitsIndex < ulimitsJsonList.GetLength(); ++ulimitsIndex)
{
ulimitsJsonList[ulimitsIndex].AsObject(m_ulimits[ulimitsIndex].Jsonize());
}
payload.WithArray("ulimits", std::move(ulimitsJsonList));
}
if(m_logConfigurationHasBeenSet)
{
payload.WithObject("logConfiguration", m_logConfiguration.Jsonize());
}
return payload;
}
Aws::String CreateUserPoolClientRequest::SerializePayload() const
{
JsonValue payload;
if(m_userPoolIdHasBeenSet)
{
payload.WithString("UserPoolId", m_userPoolId);
}
if(m_clientNameHasBeenSet)
{
payload.WithString("ClientName", m_clientName);
}
if(m_generateSecretHasBeenSet)
{
payload.WithBool("GenerateSecret", m_generateSecret);
}
if(m_refreshTokenValidityHasBeenSet)
{
payload.WithInteger("RefreshTokenValidity", m_refreshTokenValidity);
}
if(m_readAttributesHasBeenSet)
{
Array<JsonValue> readAttributesJsonList(m_readAttributes.size());
for(unsigned readAttributesIndex = 0; readAttributesIndex < readAttributesJsonList.GetLength(); ++readAttributesIndex)
{
readAttributesJsonList[readAttributesIndex].AsString(m_readAttributes[readAttributesIndex]);
}
payload.WithArray("ReadAttributes", std::move(readAttributesJsonList));
}
if(m_writeAttributesHasBeenSet)
{
Array<JsonValue> writeAttributesJsonList(m_writeAttributes.size());
for(unsigned writeAttributesIndex = 0; writeAttributesIndex < writeAttributesJsonList.GetLength(); ++writeAttributesIndex)
{
writeAttributesJsonList[writeAttributesIndex].AsString(m_writeAttributes[writeAttributesIndex]);
}
payload.WithArray("WriteAttributes", std::move(writeAttributesJsonList));
}
if(m_explicitAuthFlowsHasBeenSet)
{
Array<JsonValue> explicitAuthFlowsJsonList(m_explicitAuthFlows.size());
for(unsigned explicitAuthFlowsIndex = 0; explicitAuthFlowsIndex < explicitAuthFlowsJsonList.GetLength(); ++explicitAuthFlowsIndex)
{
explicitAuthFlowsJsonList[explicitAuthFlowsIndex].AsString(ExplicitAuthFlowsTypeMapper::GetNameForExplicitAuthFlowsType(m_explicitAuthFlows[explicitAuthFlowsIndex]));
}
payload.WithArray("ExplicitAuthFlows", std::move(explicitAuthFlowsJsonList));
}
return payload.WriteReadable();
}
JsonValue Route::Jsonize() const
{
JsonValue payload;
if(m_apiKeyRequiredHasBeenSet)
{
payload.WithBool("apiKeyRequired", m_apiKeyRequired);
}
if(m_authorizationScopesHasBeenSet)
{
Array<JsonValue> authorizationScopesJsonList(m_authorizationScopes.size());
for(unsigned authorizationScopesIndex = 0; authorizationScopesIndex < authorizationScopesJsonList.GetLength(); ++authorizationScopesIndex)
{
authorizationScopesJsonList[authorizationScopesIndex].AsString(m_authorizationScopes[authorizationScopesIndex]);
}
payload.WithArray("authorizationScopes", std::move(authorizationScopesJsonList));
}
if(m_authorizationTypeHasBeenSet)
{
payload.WithString("authorizationType", AuthorizationTypeMapper::GetNameForAuthorizationType(m_authorizationType));
}
if(m_authorizerIdHasBeenSet)
{
payload.WithString("authorizerId", m_authorizerId);
}
if(m_modelSelectionExpressionHasBeenSet)
{
payload.WithString("modelSelectionExpression", m_modelSelectionExpression);
}
if(m_operationNameHasBeenSet)
{
payload.WithString("operationName", m_operationName);
}
if(m_requestModelsHasBeenSet)
{
JsonValue requestModelsJsonMap;
for(auto& requestModelsItem : m_requestModels)
{
requestModelsJsonMap.WithString(requestModelsItem.first, requestModelsItem.second);
}
payload.WithObject("requestModels", std::move(requestModelsJsonMap));
}
if(m_requestParametersHasBeenSet)
{
JsonValue requestParametersJsonMap;
for(auto& requestParametersItem : m_requestParameters)
{
requestParametersJsonMap.WithObject(requestParametersItem.first, requestParametersItem.second.Jsonize());
}
payload.WithObject("requestParameters", std::move(requestParametersJsonMap));
}
if(m_routeIdHasBeenSet)
{
payload.WithString("routeId", m_routeId);
}
if(m_routeKeyHasBeenSet)
{
payload.WithString("routeKey", m_routeKey);
}
if(m_routeResponseSelectionExpressionHasBeenSet)
{
payload.WithString("routeResponseSelectionExpression", m_routeResponseSelectionExpression);
}
if(m_targetHasBeenSet)
{
payload.WithString("target", m_target);
}
return payload;
}
