DeploymentCommand& DeploymentCommand::operator =(const JsonValue& jsonValue)
{
if(jsonValue.ValueExists("Name"))
{
m_name = DeploymentCommandNameMapper::GetDeploymentCommandNameForName(jsonValue.GetString("Name"));
m_nameHasBeenSet = true;
}
if(jsonValue.ValueExists("Args"))
{
Aws::Map<Aws::String, JsonValue> argsJsonMap = jsonValue.GetObject("Args").GetAllObjects();
for(auto& argsItem : argsJsonMap)
{
Array<JsonValue> stringsJsonList = argsItem.second.AsArray();
Aws::Vector<Aws::String> stringsList;
stringsList.reserve((size_t)stringsJsonList.GetLength());
for(unsigned stringsIndex = 0; stringsIndex < stringsJsonList.GetLength(); ++stringsIndex)
{
stringsList.push_back(stringsJsonList[stringsIndex].AsString());
}
m_args[argsItem.first] = std::move(stringsList);
}
m_argsHasBeenSet = true;
}
return *this;
}
void URI::SetPath(const Aws::String& value, bool shouldEncode)
{
//we need to url encode the path parts (mainly to take care of spaces that a user might put here)
if (shouldEncode)
{
Aws::Vector<Aws::String> pathParts = StringUtils::Split(value, '/');
Aws::StringStream ss;
for (Aws::Vector<Aws::String>::iterator iter = pathParts.begin(); iter != pathParts.end(); ++iter)
{
ss << '/' << StringUtils::URLEncode(iter->c_str());
}
//if the last character was also a slash, then add that back here.
if (value[value.length() - 1] == '/')
{
ss << '/';
}
path = ss.str();
}
else
{
path = value;
}
}
size_t CurlHttpClient::WriteHeader(char* ptr, size_t size, size_t nmemb, void* userdata)
{
if (ptr)
{
AWS_LOGSTREAM_TRACE(CURL_HTTP_CLIENT_TAG, ptr);
HttpResponse* response = (HttpResponse*) userdata;
Aws::String headerLine(ptr);
Aws::Vector<Aws::String> keyValuePair = StringUtils::Split(headerLine, ':');
if (keyValuePair.size() > 1)
{
Aws::String headerName = keyValuePair[0];
headerName = StringUtils::Trim(headerName.c_str());
Aws::String headerValue = headerLine.substr(headerName.length() + 1).c_str();
headerValue = StringUtils::Trim(headerValue.c_str());
response->AddHeader(headerName, headerValue);
}
return size * nmemb;
}
return 0;
}
TEST(StringUtilsTest, TestSplitWithEmptyString)
{
AWS_BEGIN_MEMORY_TEST(16, 10)
Aws::String toSplit = "";
Aws::Vector<Aws::String> splits = StringUtils::Split(toSplit, ',');
ASSERT_EQ(0uL, splits.size());
AWS_END_MEMORY_TEST
}
TEST(StringUtilsTest, TestSplitDelimiterNotFound)
{
AWS_BEGIN_MEMORY_TEST(16, 10)
Aws::String toSplit = "BlahBlahBlah";
Aws::Vector<Aws::String> splits = StringUtils::Split(toSplit, ',');
ASSERT_EQ(1uL, splits.size());
AWS_END_MEMORY_TEST
}
AttributeValue& AttributeValue::AddNItem(const Aws::String& nItem)
{
if (!m_value)
{
Aws::Vector<Aws::String> ns;
ns.push_back(nItem);
m_value = Aws::MakeShared<AttributeValueNumberSet>("AttributeValue", ns);
}
else
{
m_value->AddNItem(nItem);
}
return *this;
}
AttributeValue& AttributeValue::AddSItem(const Aws::String& sItem)
{
if (!m_value)
{
Aws::Vector<Aws::String> ss;
ss.push_back(sItem);
m_value = Aws::MakeShared<AttributeValueStringSet>("AttributeValue", ss);
}
else
{
m_value->AddSItem(sItem);
}
return *this;
}
AttributeValue& AttributeValue::AddBItem(const ByteBuffer& bItem)
{
if (!m_value)
{
Aws::Vector<ByteBuffer> bs;
bs.push_back(bItem);
m_value = Aws::MakeShared<AttributeValueByteBufferSet>("AttributeValue", bs);
}
else
{
m_value->AddBItem(bItem);
}
return *this;
}
Aws::Vector<Aws::String> Directory::GetAllFilePathsInDirectory(const Aws::String& path)
{
Aws::FileSystem::DirectoryTree tree(path);
Aws::Vector<Aws::String> filesVector;
auto visitor = [&](const Aws::FileSystem::DirectoryTree*, const Aws::FileSystem::DirectoryEntry& entry)
{
if (entry.fileType == Aws::FileSystem::FileType::File)
{
filesVector.push_back(entry.path);
}
return true;
};
tree.TraverseBreadthFirst(visitor);
return filesVector;
}
TEST(StringUtilsTest, TestSplitHappyPath)
{
AWS_BEGIN_MEMORY_TEST(16, 10)
Aws::String toSplit = "test1,test2,test3,test4";
Aws::Vector<Aws::String> splits = StringUtils::Split(toSplit, ',');
ASSERT_EQ(4uL, splits.size());
EXPECT_STREQ("test1", splits[0].c_str());
EXPECT_STREQ("test2", splits[1].c_str());
EXPECT_STREQ("test3", splits[2].c_str());
EXPECT_STREQ("test4", splits[3].c_str());
AWS_END_MEMORY_TEST
}
AttributeValue& AttributeValue::AddLItem(const std::shared_ptr<AttributeValue>& listItem)
{
if (!m_value)
{
Aws::Vector<std::shared_ptr<AttributeValue>> list;
list.push_back(listItem);
m_value = Aws::MakeShared<AttributeValueList>("AttributeValue", list);
}
else
{
m_value->AddLItem(listItem);
}
return *this;
}
Hit& Hit::operator =(const JsonValue& jsonValue)
{
if(jsonValue.ValueExists("id"))
{
m_id = jsonValue.GetString("id");
m_idHasBeenSet = true;
}
if(jsonValue.ValueExists("fields"))
{
Aws::Map<Aws::String, JsonValue> fieldsJsonMap = jsonValue.GetObject("fields").GetAllObjects();
for(auto& fieldsItem : fieldsJsonMap)
{
Array<JsonValue> fieldValueJsonList = fieldsItem.second.AsArray();
Aws::Vector<Aws::String> fieldValueList;
fieldValueList.reserve((size_t)fieldValueJsonList.GetLength());
for(unsigned fieldValueIndex = 0; fieldValueIndex < fieldValueJsonList.GetLength(); ++fieldValueIndex)
{
fieldValueList.push_back(fieldValueJsonList[fieldValueIndex].AsString());
}
m_fields[fieldsItem.first] = std::move(fieldValueList);
}
m_fieldsHasBeenSet = true;
}
if(jsonValue.ValueExists("exprs"))
{
Aws::Map<Aws::String, JsonValue> exprsJsonMap = jsonValue.GetObject("exprs").GetAllObjects();
for(auto& exprsItem : exprsJsonMap)
{
m_exprs[exprsItem.first] = exprsItem.second.AsString();
}
m_exprsHasBeenSet = true;
}
if(jsonValue.ValueExists("highlights"))
{
Aws::Map<Aws::String, JsonValue> highlightsJsonMap = jsonValue.GetObject("highlights").GetAllObjects();
for(auto& highlightsItem : highlightsJsonMap)
{
m_highlights[highlightsItem.first] = highlightsItem.second.AsString();
}
m_highlightsHasBeenSet = true;
}
return *this;
}
TEST(StringUtilsTest, TestSplitWithDelimiterOnTheFrontAndBack)
{
AWS_BEGIN_MEMORY_TEST(16, 10)
Aws::String toSplit = ",test1,test2,test3,test4,";
Aws::Vector<Aws::String> splits = StringUtils::Split(toSplit, ',');
ASSERT_EQ(4uL, splits.size());
EXPECT_STREQ("test1", splits[0].c_str());
EXPECT_STREQ("test2", splits[1].c_str());
EXPECT_STREQ("test3", splits[2].c_str());
EXPECT_STREQ("test4", splits[3].c_str());
AWS_END_MEMORY_TEST
}
void VerifyAllLogsAtOrBelow(LogLevel logLevel, const Aws::String& tag, const Aws::Vector<Aws::String>& loggedStatements)
{
static const uint32_t STATEMENTS_PER_LEVEL = 3;
uint32_t expectedLogLevels = static_cast<uint32_t>(logLevel);
uint32_t expectedStatementCount = expectedLogLevels * STATEMENTS_PER_LEVEL;
ASSERT_EQ(expectedStatementCount, loggedStatements.size());
for(uint32_t i = 0; i < expectedLogLevels; ++i)
{
LogLevel currentLevel = static_cast<LogLevel>(i + 1);
Aws::String levelTag = "[" + GetLogLevelName(currentLevel) + "]";
for(uint32_t j = 0; j < STATEMENTS_PER_LEVEL; ++j)
{
uint32_t statementIndex = i * STATEMENTS_PER_LEVEL + j;
ASSERT_TRUE(loggedStatements[statementIndex].find(levelTag) != Aws::String::npos);
ASSERT_TRUE(loggedStatements[statementIndex].find(tag) != Aws::String::npos);
}
Aws::String logText1 = "test " + StringUtils::ToLower(GetLogLevelName(currentLevel).c_str()) + " level";
ASSERT_TRUE(loggedStatements[i * STATEMENTS_PER_LEVEL].find(logText1) != Aws::String::npos);
Aws::String logText2 = "test " + StringUtils::ToLower(GetLogLevelName(currentLevel).c_str()) + " format level";
ASSERT_TRUE(loggedStatements[i * STATEMENTS_PER_LEVEL + 1].find(logText2) != Aws::String::npos);
Aws::String logText3 = "test " + StringUtils::ToLower(GetLogLevelName(currentLevel).c_str()) + " stream level";
ASSERT_TRUE(loggedStatements[i * STATEMENTS_PER_LEVEL + 2].find(logText3) != Aws::String::npos);
}
}
Aws::Vector<Aws::String> StringUtils::SplitOnLine(const Aws::String& toSplit)
{
Aws::StringStream input(toSplit);
Aws::Vector<Aws::String> returnValues;
Aws::String item;
while (std::getline(input, item))
{
if (item.size() > 0)
{
returnValues.push_back(item);
}
}
return std::move(returnValues);
}
TEST(StringUtilsTest, TestSplitOnLineHappyPath)
{
AWS_BEGIN_MEMORY_TEST(16, 10)
Aws::StringStream ss;
ss << "test1" << std::endl << "test2" << std::endl << "test3" << std::endl << "test4";
Aws::String toSplit = ss.str();
Aws::Vector<Aws::String> splits = StringUtils::SplitOnLine(toSplit);
ASSERT_EQ(4uL, splits.size());
EXPECT_STREQ("test1", splits[0].c_str());
EXPECT_STREQ("test2", splits[1].c_str());
EXPECT_STREQ("test3", splits[2].c_str());
EXPECT_STREQ("test4", splits[3].c_str());
AWS_END_MEMORY_TEST
}
Aws::String URI::URLEncodePath(const Aws::String& path)
{
Aws::Vector<Aws::String> pathParts = StringUtils::Split(path, '/');
Aws::StringStream ss;
for (Aws::Vector<Aws::String>::iterator iter = pathParts.begin(); iter != pathParts.end(); ++iter)
{
ss << '/' << StringUtils::URLEncode(iter->c_str());
}
//if the last character was also a slash, then add that back here.
if (path[path.length() - 1] == '/')
{
ss << '/';
}
return ss.str();
}
Aws::Map<Aws::String, Aws::String> ProfileConfigFileAWSCredentialsProvider::ParseProfileConfigFile(const Aws::String& filename)
{
std::ifstream profileFile(filename.c_str());
Aws::Map<Aws::String, Aws::String> propertyValueMap;
Aws::String profile = "";
if (profileFile.good() && profileFile.is_open())
{
Aws::String line;
while (std::getline(profileFile, line))
{
Aws::String trimmedLine(StringUtils::Trim(line.c_str()));
if (trimmedLine.empty() || trimmedLine.front() == '#')
continue;
if (trimmedLine.front() == '[' && trimmedLine.back() == ']')
{
profile = StringUtils::Trim(trimmedLine.substr(1, trimmedLine.length() - 2).c_str());
AWS_LOGSTREAM_DEBUG(profileLogTag, "Found profile " << profile);
}
Aws::Vector<Aws::String> propertyPair = StringUtils::Split(trimmedLine, '=');
if (propertyPair.size() == 2)
{
Aws::String key(StringUtils::Trim(propertyPair[0].c_str()));
Aws::String value(StringUtils::Trim(propertyPair[1].c_str()));
AWS_LOGSTREAM_TRACE(profileLogTag, "Found property " << key << "for profile " << profile);
if (key == AWS_ACCESS_KEY_ID || key == AWS_SECRET_ACCESS_KEY || key == AWS_SESSION_TOKEN || key == AWS_ACCOUNT_ID)
propertyValueMap[profile + ":" + key] = value;
}
}
}
if (profileFile.is_open())
profileFile.close();
return std::move(propertyValueMap);
}
Aws::Vector<DeviceInfo> PulseAudioPCMOutputDriver::EnumerateDevices() const
{
Aws::Vector<DeviceInfo> devices;
DeviceInfo deviceInfo;
deviceInfo.deviceId = "0";
deviceInfo.deviceName = "default audio output device";
CapabilityInfo capabilityInfo;
capabilityInfo.channels = MONO;
capabilityInfo.sampleRate = KHZ_16;
capabilityInfo.sampleWidthBits = BIT_WIDTH_16;
deviceInfo.capabilities.push_back(capabilityInfo);
capabilityInfo.sampleRate = KHZ_8;
deviceInfo.capabilities.push_back(capabilityInfo);
devices.push_back(deviceInfo);
return devices;
}
void deleteObjects(ClientPtrType client, String bucketName, String prefix, size_t num)
{
String base = "=== Delete Objects [" + bucketName + "/" + prefix;
std::cout << base << "]: Start ===\n";
Aws::Vector<Aws::S3::Model::ObjectIdentifier> objects;
for (size_t i = 0; i < num; ++i)
{
objects.push_back(Aws::S3::Model::ObjectIdentifier().WithKey(prefix + std::to_string(i).c_str()));
}
auto objReq = Aws::S3::Model::DeleteObjectsRequest();
objReq.WithBucket(bucketName).WithDelete(Aws::S3::Model::Delete().WithObjects(objects));
auto objRes = client->DeleteObjects(objReq);
if (!objRes.IsSuccess())
{
std::cout << base << "]: Client Side failure ===\n";
}/*
if (std::get<0>(doesObjectExists(client, bucketName, key)))
{
std::cout << base << "]: Deletion of " << key << " Failed ===\n";
}*/
std::cout << base << "]: End ===\n\n";
}
TraceSummary& TraceSummary::operator =(const JsonValue& jsonValue)
{
if(jsonValue.ValueExists("Id"))
{
m_id = jsonValue.GetString("Id");
m_idHasBeenSet = true;
}
if(jsonValue.ValueExists("Duration"))
{
m_duration = jsonValue.GetDouble("Duration");
m_durationHasBeenSet = true;
}
if(jsonValue.ValueExists("ResponseTime"))
{
m_responseTime = jsonValue.GetDouble("ResponseTime");
m_responseTimeHasBeenSet = true;
}
if(jsonValue.ValueExists("HasFault"))
{
m_hasFault = jsonValue.GetBool("HasFault");
m_hasFaultHasBeenSet = true;
}
if(jsonValue.ValueExists("HasError"))
{
m_hasError = jsonValue.GetBool("HasError");
m_hasErrorHasBeenSet = true;
}
if(jsonValue.ValueExists("HasThrottle"))
{
m_hasThrottle = jsonValue.GetBool("HasThrottle");
m_hasThrottleHasBeenSet = true;
}
if(jsonValue.ValueExists("IsPartial"))
{
m_isPartial = jsonValue.GetBool("IsPartial");
m_isPartialHasBeenSet = true;
}
if(jsonValue.ValueExists("Http"))
{
m_http = jsonValue.GetObject("Http");
m_httpHasBeenSet = true;
}
if(jsonValue.ValueExists("Annotations"))
{
Aws::Map<Aws::String, JsonValue> annotationsJsonMap = jsonValue.GetObject("Annotations").GetAllObjects();
for(auto& annotationsItem : annotationsJsonMap)
{
Array<JsonValue> valuesWithServiceIdsJsonList = annotationsItem.second.AsArray();
Aws::Vector<ValueWithServiceIds> valuesWithServiceIdsList;
valuesWithServiceIdsList.reserve((size_t)valuesWithServiceIdsJsonList.GetLength());
for(unsigned valuesWithServiceIdsIndex = 0; valuesWithServiceIdsIndex < valuesWithServiceIdsJsonList.GetLength(); ++valuesWithServiceIdsIndex)
{
valuesWithServiceIdsList.push_back(valuesWithServiceIdsJsonList[valuesWithServiceIdsIndex].AsObject());
}
m_annotations[annotationsItem.first] = std::move(valuesWithServiceIdsList);
}
m_annotationsHasBeenSet = true;
}
if(jsonValue.ValueExists("Users"))
{
Array<JsonValue> usersJsonList = jsonValue.GetArray("Users");
for(unsigned usersIndex = 0; usersIndex < usersJsonList.GetLength(); ++usersIndex)
{
m_users.push_back(usersJsonList[usersIndex].AsObject());
}
m_usersHasBeenSet = true;
}
if(jsonValue.ValueExists("ServiceIds"))
{
Array<JsonValue> serviceIdsJsonList = jsonValue.GetArray("ServiceIds");
for(unsigned serviceIdsIndex = 0; serviceIdsIndex < serviceIdsJsonList.GetLength(); ++serviceIdsIndex)
{
m_serviceIds.push_back(serviceIdsJsonList[serviceIdsIndex].AsObject());
}
m_serviceIdsHasBeenSet = true;
}
return *this;
}
AutomationExecution& AutomationExecution::operator =(const JsonValue& jsonValue)
{
if(jsonValue.ValueExists("AutomationExecutionId"))
{
m_automationExecutionId = jsonValue.GetString("AutomationExecutionId");
m_automationExecutionIdHasBeenSet = true;
}
if(jsonValue.ValueExists("DocumentName"))
{
m_documentName = jsonValue.GetString("DocumentName");
m_documentNameHasBeenSet = true;
}
if(jsonValue.ValueExists("DocumentVersion"))
{
m_documentVersion = jsonValue.GetString("DocumentVersion");
m_documentVersionHasBeenSet = true;
}
if(jsonValue.ValueExists("ExecutionStartTime"))
{
m_executionStartTime = jsonValue.GetDouble("ExecutionStartTime");
m_executionStartTimeHasBeenSet = true;
}
if(jsonValue.ValueExists("ExecutionEndTime"))
{
m_executionEndTime = jsonValue.GetDouble("ExecutionEndTime");
m_executionEndTimeHasBeenSet = true;
}
if(jsonValue.ValueExists("AutomationExecutionStatus"))
{
m_automationExecutionStatus = AutomationExecutionStatusMapper::GetAutomationExecutionStatusForName(jsonValue.GetString("AutomationExecutionStatus"));
m_automationExecutionStatusHasBeenSet = true;
}
if(jsonValue.ValueExists("StepExecutions"))
{
Array<JsonValue> stepExecutionsJsonList = jsonValue.GetArray("StepExecutions");
for(unsigned stepExecutionsIndex = 0; stepExecutionsIndex < stepExecutionsJsonList.GetLength(); ++stepExecutionsIndex)
{
m_stepExecutions.push_back(stepExecutionsJsonList[stepExecutionsIndex].AsObject());
}
m_stepExecutionsHasBeenSet = true;
}
if(jsonValue.ValueExists("Parameters"))
{
Aws::Map<Aws::String, JsonValue> parametersJsonMap = jsonValue.GetObject("Parameters").GetAllObjects();
for(auto& parametersItem : parametersJsonMap)
{
Array<JsonValue> automationParameterValueListJsonList = parametersItem.second.AsArray();
Aws::Vector<Aws::String> automationParameterValueListList;
automationParameterValueListList.reserve((size_t)automationParameterValueListJsonList.GetLength());
for(unsigned automationParameterValueListIndex = 0; automationParameterValueListIndex < automationParameterValueListJsonList.GetLength(); ++automationParameterValueListIndex)
{
automationParameterValueListList.push_back(automationParameterValueListJsonList[automationParameterValueListIndex].AsString());
}
m_parameters[parametersItem.first] = std::move(automationParameterValueListList);
}
m_parametersHasBeenSet = true;
}
if(jsonValue.ValueExists("Outputs"))
{
Aws::Map<Aws::String, JsonValue> outputsJsonMap = jsonValue.GetObject("Outputs").GetAllObjects();
for(auto& outputsItem : outputsJsonMap)
{
Array<JsonValue> automationParameterValueListJsonList = outputsItem.second.AsArray();
Aws::Vector<Aws::String> automationParameterValueListList;
automationParameterValueListList.reserve((size_t)automationParameterValueListJsonList.GetLength());
for(unsigned automationParameterValueListIndex = 0; automationParameterValueListIndex < automationParameterValueListJsonList.GetLength(); ++automationParameterValueListIndex)
{
automationParameterValueListList.push_back(automationParameterValueListJsonList[automationParameterValueListIndex].AsString());
}
m_outputs[outputsItem.first] = std::move(automationParameterValueListList);
}
m_outputsHasBeenSet = true;
}
if(jsonValue.ValueExists("FailureMessage"))
{
m_failureMessage = jsonValue.GetString("FailureMessage");
m_failureMessageHasBeenSet = true;
}
return *this;
}
std::shared_ptr<HttpResponse> WinSyncHttpClient::BuildSuccessResponse(const Aws::Http::HttpRequest& request, void* hHttpRequest, Aws::Utils::RateLimits::RateLimiterInterface* readLimiter) const
{
auto response = Aws::MakeShared<StandardHttpResponse>(GetLogTag(), request);
Aws::StringStream ss;
uint64_t read = 0;
DoQueryHeaders(hHttpRequest, response, ss, read);
if(readLimiter != nullptr && read > 0)
{
readLimiter->ApplyAndPayForCost(read);
}
Aws::Vector<Aws::String> rawHeaders = StringUtils::SplitOnLine(ss.str());
for (auto& header : rawHeaders)
{
Aws::Vector<Aws::String> keyValuePair = StringUtils::Split(header, ':');
if (keyValuePair.size() > 1)
{
Aws::String headerName = keyValuePair[0];
headerName = StringUtils::Trim(headerName.c_str());
Aws::String headerValue(keyValuePair[1]);
for (unsigned i = 2; i < keyValuePair.size(); ++i)
{
headerValue += ":";
headerValue += keyValuePair[i];
}
response->AddHeader(headerName, StringUtils::Trim(headerValue.c_str()));
}
}
if (request.GetMethod() != HttpMethod::HTTP_HEAD)
{
char body[1024];
uint64_t bodySize = sizeof(body);
read = 0;
bool success = true;
while (DoReadData(hHttpRequest, body, bodySize, read) && read > 0 && success)
{
response->GetResponseBody().write(body, read);
if (read > 0)
{
if (readLimiter != nullptr)
{
readLimiter->ApplyAndPayForCost(read);
}
auto& receivedHandler = request.GetDataReceivedEventHandler();
if (receivedHandler)
{
receivedHandler(&request, response.get(), (long long)read);
}
}
success = success && IsRequestProcessingEnabled();
}
if(!success)
{
return nullptr;
}
}
//go ahead and flush the response body.
response->GetResponseBody().flush();
return response;
}
TestInvokeAuthorizerResult& TestInvokeAuthorizerResult::operator =(const AmazonWebServiceResult<JsonValue>& result)
{
const JsonValue& jsonValue = result.GetPayload();
if(jsonValue.ValueExists("clientStatus"))
{
m_clientStatus = jsonValue.GetInteger("clientStatus");
}
if(jsonValue.ValueExists("log"))
{
m_log = jsonValue.GetString("log");
}
if(jsonValue.ValueExists("latency"))
{
m_latency = jsonValue.GetInt64("latency");
}
if(jsonValue.ValueExists("principalId"))
{
m_principalId = jsonValue.GetString("principalId");
}
if(jsonValue.ValueExists("policy"))
{
m_policy = jsonValue.GetString("policy");
}
if(jsonValue.ValueExists("authorization"))
{
Aws::Map<Aws::String, JsonValue> authorizationJsonMap = jsonValue.GetObject("authorization").GetAllObjects();
for(auto& authorizationItem : authorizationJsonMap)
{
Array<JsonValue> listOfStringJsonList = authorizationItem.second.AsArray();
Aws::Vector<Aws::String> listOfStringList;
listOfStringList.reserve((size_t)listOfStringJsonList.GetLength());
for(unsigned listOfStringIndex = 0; listOfStringIndex < listOfStringJsonList.GetLength(); ++listOfStringIndex)
{
listOfStringList.push_back(listOfStringJsonList[listOfStringIndex].AsString());
}
m_authorization[authorizationItem.first] = std::move(listOfStringList);
}
}
if(jsonValue.ValueExists("claims"))
{
Aws::Map<Aws::String, JsonValue> claimsJsonMap = jsonValue.GetObject("claims").GetAllObjects();
for(auto& claimsItem : claimsJsonMap)
{
m_claims[claimsItem.first] = claimsItem.second.AsString();
}
}
return *this;
}
StepExecution& StepExecution::operator =(const JsonValue& jsonValue)
{
if(jsonValue.ValueExists("StepName"))
{
m_stepName = jsonValue.GetString("StepName");
m_stepNameHasBeenSet = true;
}
if(jsonValue.ValueExists("Action"))
{
m_action = jsonValue.GetString("Action");
m_actionHasBeenSet = true;
}
if(jsonValue.ValueExists("ExecutionStartTime"))
{
m_executionStartTime = jsonValue.GetDouble("ExecutionStartTime");
m_executionStartTimeHasBeenSet = true;
}
if(jsonValue.ValueExists("ExecutionEndTime"))
{
m_executionEndTime = jsonValue.GetDouble("ExecutionEndTime");
m_executionEndTimeHasBeenSet = true;
}
if(jsonValue.ValueExists("StepStatus"))
{
m_stepStatus = AutomationExecutionStatusMapper::GetAutomationExecutionStatusForName(jsonValue.GetString("StepStatus"));
m_stepStatusHasBeenSet = true;
}
if(jsonValue.ValueExists("ResponseCode"))
{
m_responseCode = jsonValue.GetString("ResponseCode");
m_responseCodeHasBeenSet = true;
}
if(jsonValue.ValueExists("Inputs"))
{
Aws::Map<Aws::String, JsonValue> inputsJsonMap = jsonValue.GetObject("Inputs").GetAllObjects();
for(auto& inputsItem : inputsJsonMap)
{
m_inputs[inputsItem.first] = inputsItem.second.AsString();
}
m_inputsHasBeenSet = true;
}
if(jsonValue.ValueExists("Outputs"))
{
Aws::Map<Aws::String, JsonValue> outputsJsonMap = jsonValue.GetObject("Outputs").GetAllObjects();
for(auto& outputsItem : outputsJsonMap)
{
Array<JsonValue> automationParameterValueListJsonList = outputsItem.second.AsArray();
Aws::Vector<Aws::String> automationParameterValueListList;
automationParameterValueListList.reserve((size_t)automationParameterValueListJsonList.GetLength());
for(unsigned automationParameterValueListIndex = 0; automationParameterValueListIndex < automationParameterValueListJsonList.GetLength(); ++automationParameterValueListIndex)
{
automationParameterValueListList.push_back(automationParameterValueListJsonList[automationParameterValueListIndex].AsString());
}
m_outputs[outputsItem.first] = std::move(automationParameterValueListList);
}
m_outputsHasBeenSet = true;
}
if(jsonValue.ValueExists("Response"))
{
m_response = jsonValue.GetString("Response");
m_responseHasBeenSet = true;
}
if(jsonValue.ValueExists("FailureMessage"))
{
m_failureMessage = jsonValue.GetString("FailureMessage");
m_failureMessageHasBeenSet = true;
}
if(jsonValue.ValueExists("FailureDetails"))
{
m_failureDetails = jsonValue.GetObject("FailureDetails");
m_failureDetailsHasBeenSet = true;
}
return *this;
}
