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; }