JsonValue HealthCheck::Jsonize() const
{
JsonValue payload;
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_intervalHasBeenSet)
{
payload.WithInteger("interval", m_interval);
}
if(m_timeoutHasBeenSet)
{
payload.WithInteger("timeout", m_timeout);
}
if(m_retriesHasBeenSet)
{
payload.WithInteger("retries", m_retries);
}
if(m_startPeriodHasBeenSet)
{
payload.WithInteger("startPeriod", m_startPeriod);
}
return payload;
}
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;
}
