GetFieldLevelEncryptionConfig2018_06_18Result& GetFieldLevelEncryptionConfig2018_06_18Result::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode resultNode = xmlDocument.GetRootElement();

  if(!resultNode.IsNull())
  {
    m_fieldLevelEncryptionConfig = resultNode;
  }

  const auto& headers = result.GetHeaderValueCollection();
  const auto& eTagIter = headers.find("etag");
  if(eTagIter != headers.end())
  {
    m_eTag = eTagIter->second;
  }

  return *this;
}
DeleteReceiptRuleSetResult& DeleteReceiptRuleSetResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (rootNode.GetName() != "DeleteReceiptRuleSetResult")
  {
    resultNode = rootNode.FirstChild("DeleteReceiptRuleSetResult");
  }

  if(!resultNode.IsNull())
  {
  }

  XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
  m_responseMetadata = responseMetadataNode;

  return *this;
}
UpdateStreamingDistribution2016_01_28Result& UpdateStreamingDistribution2016_01_28Result::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode resultNode = xmlDocument.GetRootElement();

  if(!resultNode.IsNull())
  {
    m_streamingDistribution = resultNode;
  }

  const auto& headers = result.GetHeaderValueCollection();
  const auto& eTagIter = headers.find("etag");
  if(eTagIter != headers.end())
  {
    m_eTag = eTagIter->second;
  }

  return *this;
}
CreateInvalidation2016_01_28Result& CreateInvalidation2016_01_28Result::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode resultNode = xmlDocument.GetRootElement();

  if(!resultNode.IsNull())
  {
    m_invalidation = resultNode;
  }

  const auto& headers = result.GetHeaderValueCollection();
  const auto& locationIter = headers.find("location");
  if(locationIter != headers.end())
  {
    m_location = locationIter->second;
  }

  return *this;
}
GetCloudFrontOriginAccessIdentity2016_01_28Result& GetCloudFrontOriginAccessIdentity2016_01_28Result::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode resultNode = xmlDocument.GetRootElement();

  if(!resultNode.IsNull())
  {
    m_cloudFrontOriginAccessIdentity = resultNode;
  }

  const auto& headers = result.GetHeaderValueCollection();
  const auto& eTagIter = headers.find("etag");
  if(eTagIter != headers.end())
  {
    m_eTag = eTagIter->second;
  }

  return *this;
}
GetBucketNotificationConfigurationResult& GetBucketNotificationConfigurationResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode resultNode = xmlDocument.GetRootElement();

  if(!resultNode.IsNull())
  {
    XmlNode topicConfigurationsNode = resultNode.FirstChild("TopicConfigurations");
    if(!topicConfigurationsNode.IsNull())
    {
      XmlNode topicConfigurationsMember = topicConfigurationsNode;
      while(!topicConfigurationsMember.IsNull())
      {
        m_topicConfigurations.push_back(topicConfigurationsMember);
        topicConfigurationsMember = topicConfigurationsMember.NextNode("TopicConfiguration");
      }

    }
    XmlNode queueConfigurationsNode = resultNode.FirstChild("QueueConfigurations");
    if(!queueConfigurationsNode.IsNull())
    {
      XmlNode queueConfigurationsMember = queueConfigurationsNode;
      while(!queueConfigurationsMember.IsNull())
      {
        m_queueConfigurations.push_back(queueConfigurationsMember);
        queueConfigurationsMember = queueConfigurationsMember.NextNode("QueueConfiguration");
      }

    }
    XmlNode lambdaFunctionConfigurationsNode = resultNode.FirstChild("LambdaFunctionConfigurations");
    if(!lambdaFunctionConfigurationsNode.IsNull())
    {
      XmlNode lambdaFunctionConfigurationsMember = lambdaFunctionConfigurationsNode;
      while(!lambdaFunctionConfigurationsMember.IsNull())
      {
        m_lambdaFunctionConfigurations.push_back(lambdaFunctionConfigurationsMember);
        lambdaFunctionConfigurationsMember = lambdaFunctionConfigurationsMember.NextNode("CloudFunctionConfiguration");
      }

    }
  }

  return *this;
}
LoadBalancerDescription& LoadBalancerDescription::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode loadBalancerNameNode = resultNode.FirstChild("LoadBalancerName");
    if(loadBalancerNameNode.IsNull())
    {
      loadBalancerNameNode = resultNode;
    }

    if(!loadBalancerNameNode.IsNull())
    {
      m_loadBalancerName = StringUtils::Trim(loadBalancerNameNode.GetText().c_str());
      m_loadBalancerNameHasBeenSet = true;
    }
    XmlNode domainNode = resultNode.FirstChild("Domain");
    if(domainNode.IsNull())
    {
      domainNode = resultNode;
    }

    if(!domainNode.IsNull())
    {
      m_domain = StringUtils::Trim(domainNode.GetText().c_str());
      m_domainHasBeenSet = true;
    }
    XmlNode listenersNode = resultNode.FirstChild("Listeners");
    if(!listenersNode.IsNull())
    {
      XmlNode listenersMember = listenersNode.FirstChild("member");
      while(!listenersMember.IsNull())
      {
        m_listeners.push_back(listenersMember);
        listenersMember = listenersMember.NextNode("member");
      }

      m_listenersHasBeenSet = true;
    }
  }

  return *this;
}
SetIdentityFeedbackForwardingEnabledResult& SetIdentityFeedbackForwardingEnabledResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (rootNode.GetName() != "SetIdentityFeedbackForwardingEnabledResult")
  {
    resultNode = rootNode.FirstChild("SetIdentityFeedbackForwardingEnabledResult");
  }

  if(!resultNode.IsNull())
  {
  }

  XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
  m_responseMetadata = responseMetadataNode;
  AWS_LOGSTREAM_DEBUG("Aws::SES::Model::SetIdentityFeedbackForwardingEnabledResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );

  return *this;
}
TopicConfigurationDeprecated& TopicConfigurationDeprecated::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode idNode = resultNode.FirstChild("Id");
    if(idNode.IsNull())
    {
      idNode = resultNode;
    }

    if(!idNode.IsNull())
    {
      m_id = StringUtils::Trim(idNode.GetText().c_str());
      m_idHasBeenSet = true;
    }
    XmlNode eventsNode = resultNode.FirstChild("Events");
    if(!eventsNode.IsNull())
    {
      XmlNode eventsMember = eventsNode;
      while(!eventsMember.IsNull())
      {
        m_events.push_back(EventMapper::GetEventForName(StringUtils::Trim(eventsMember.GetText().c_str())));
        eventsMember = eventsMember.NextNode("Event");
      }

      m_eventsHasBeenSet = true;
    }
    XmlNode topicNode = resultNode.FirstChild("Topic");
    if(topicNode.IsNull())
    {
      topicNode = resultNode;
    }

    if(!topicNode.IsNull())
    {
      m_topic = StringUtils::Trim(topicNode.GetText().c_str());
      m_topicHasBeenSet = true;
    }
  }

  return *this;
}
DeleteChangeSetResult& DeleteChangeSetResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (rootNode.GetName() != "DeleteChangeSetResult")
  {
    resultNode = rootNode.FirstChild("DeleteChangeSetResult");
  }

  if(!resultNode.IsNull())
  {
  }

  XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
  m_responseMetadata = responseMetadataNode;
  AWS_LOGSTREAM_DEBUG("Aws::CloudFormation::Model::DeleteChangeSetResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );

  return *this;
}
AttachLoadBalancersResult& AttachLoadBalancersResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (rootNode.GetName() != "AttachLoadBalancersResult")
  {
    resultNode = rootNode.FirstChild("AttachLoadBalancersResult");
  }

  if(!resultNode.IsNull())
  {
  }

  XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
  m_responseMetadata = responseMetadataNode;
  AWS_LOGSTREAM_DEBUG("Aws::AutoScaling::Model::AttachLoadBalancersResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );

  return *this;
}
CreateLBCookieStickinessPolicyResult& CreateLBCookieStickinessPolicyResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (rootNode.GetName() != "CreateLBCookieStickinessPolicyResult")
  {
    resultNode = rootNode.FirstChild("CreateLBCookieStickinessPolicyResult");
  }

  if(!resultNode.IsNull())
  {
  }

  XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
  m_responseMetadata = responseMetadataNode;
  AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::CreateLBCookieStickinessPolicyResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );

  return *this;
}
DescribeLoggingStatusResult& DescribeLoggingStatusResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (rootNode.GetName() != "DescribeLoggingStatusResult")
  {
    resultNode = rootNode.FirstChild("DescribeLoggingStatusResult");
  }

  if(!resultNode.IsNull())
  {
    XmlNode loggingEnabledNode = resultNode.FirstChild("LoggingEnabled");
    if(!loggingEnabledNode.IsNull())
    {
      m_loggingEnabled = StringUtils::ConvertToBool(StringUtils::Trim(loggingEnabledNode.GetText().c_str()).c_str());
    }
    XmlNode bucketNameNode = resultNode.FirstChild("BucketName");
    if(!bucketNameNode.IsNull())
    {
      m_bucketName = StringUtils::Trim(bucketNameNode.GetText().c_str());
    }
    XmlNode s3KeyPrefixNode = resultNode.FirstChild("S3KeyPrefix");
    if(!s3KeyPrefixNode.IsNull())
    {
      m_s3KeyPrefix = StringUtils::Trim(s3KeyPrefixNode.GetText().c_str());
    }
    XmlNode lastSuccessfulDeliveryTimeNode = resultNode.FirstChild("LastSuccessfulDeliveryTime");
    if(!lastSuccessfulDeliveryTimeNode.IsNull())
    {
      m_lastSuccessfulDeliveryTime = StringUtils::ConvertToDouble(StringUtils::Trim(lastSuccessfulDeliveryTimeNode.GetText().c_str()).c_str());
    }
    XmlNode lastFailureTimeNode = resultNode.FirstChild("LastFailureTime");
    if(!lastFailureTimeNode.IsNull())
    {
      m_lastFailureTime = StringUtils::ConvertToDouble(StringUtils::Trim(lastFailureTimeNode.GetText().c_str()).c_str());
    }
    XmlNode lastFailureMessageNode = resultNode.FirstChild("LastFailureMessage");
    if(!lastFailureMessageNode.IsNull())
    {
      m_lastFailureMessage = StringUtils::Trim(lastFailureMessageNode.GetText().c_str());
    }
  }

  XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
  m_responseMetadata = responseMetadataNode;

  return *this;
}
Example #14
0
Item& Item::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode nameNode = resultNode.FirstChild("Name");
    if(nameNode.IsNull())
    {
      nameNode = resultNode;
    }

    if(!nameNode.IsNull())
    {
      m_name = StringUtils::Trim(nameNode.GetText().c_str());
      m_nameHasBeenSet = true;
    }
    XmlNode alternateNameEncodingNode = resultNode.FirstChild("AlternateNameEncoding");
    if(alternateNameEncodingNode.IsNull())
    {
      alternateNameEncodingNode = resultNode;
    }

    if(!alternateNameEncodingNode.IsNull())
    {
      m_alternateNameEncoding = StringUtils::Trim(alternateNameEncodingNode.GetText().c_str());
      m_alternateNameEncodingHasBeenSet = true;
    }
    XmlNode attributesNode = resultNode.FirstChild("Attribute");
    if(!attributesNode.IsNull())
    {
      XmlNode attributeMember = attributesNode;
      while(!attributeMember.IsNull())
      {
        m_attributes.push_back(attributeMember);
        attributeMember = attributeMember.NextNode("Attribute");
      }

      m_attributesHasBeenSet = true;
    }
  }

  return *this;
}
SAMLProviderListEntry& SAMLProviderListEntry::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode arnNode = resultNode.FirstChild("Arn");
    if(arnNode.IsNull())
    {
      arnNode = resultNode;
    }

    if(!arnNode.IsNull())
    {
      m_arn = StringUtils::Trim(arnNode.GetText().c_str());
      m_arnHasBeenSet = true;
    }
    XmlNode validUntilNode = resultNode.FirstChild("ValidUntil");
    if(validUntilNode.IsNull())
    {
      validUntilNode = resultNode;
    }

    if(!validUntilNode.IsNull())
    {
      m_validUntil = StringUtils::ConvertToDouble(StringUtils::Trim(validUntilNode.GetText().c_str()).c_str());
      m_validUntilHasBeenSet = true;
    }
    XmlNode createDateNode = resultNode.FirstChild("CreateDate");
    if(createDateNode.IsNull())
    {
      createDateNode = resultNode;
    }

    if(!createDateNode.IsNull())
    {
      m_createDate = StringUtils::ConvertToDouble(StringUtils::Trim(createDateNode.GetText().c_str()).c_str());
      m_createDateHasBeenSet = true;
    }
  }

  return *this;
}
Example #16
0
Output& Output::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode outputKeyNode = resultNode.FirstChild("OutputKey");
    if(outputKeyNode.IsNull())
    {
      outputKeyNode = resultNode;
    }

    if(!outputKeyNode.IsNull())
    {
      m_outputKey = StringUtils::Trim(outputKeyNode.GetText().c_str());
      m_outputKeyHasBeenSet = true;
    }
    XmlNode outputValueNode = resultNode.FirstChild("OutputValue");
    if(outputValueNode.IsNull())
    {
      outputValueNode = resultNode;
    }

    if(!outputValueNode.IsNull())
    {
      m_outputValue = StringUtils::Trim(outputValueNode.GetText().c_str());
      m_outputValueHasBeenSet = true;
    }
    XmlNode descriptionNode = resultNode.FirstChild("Description");
    if(descriptionNode.IsNull())
    {
      descriptionNode = resultNode;
    }

    if(!descriptionNode.IsNull())
    {
      m_description = StringUtils::Trim(descriptionNode.GetText().c_str());
      m_descriptionHasBeenSet = true;
    }
  }

  return *this;
}
CustomOriginConfig& CustomOriginConfig::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode hTTPPortNode = resultNode.FirstChild("HTTPPort");
    if(hTTPPortNode.IsNull())
    {
      hTTPPortNode = resultNode;
    }

    if(!hTTPPortNode.IsNull())
    {
      m_hTTPPort = StringUtils::ConvertToInt32(StringUtils::Trim(hTTPPortNode.GetText().c_str()).c_str());
      m_hTTPPortHasBeenSet = true;
    }
    XmlNode hTTPSPortNode = resultNode.FirstChild("HTTPSPort");
    if(hTTPSPortNode.IsNull())
    {
      hTTPSPortNode = resultNode;
    }

    if(!hTTPSPortNode.IsNull())
    {
      m_hTTPSPort = StringUtils::ConvertToInt32(StringUtils::Trim(hTTPSPortNode.GetText().c_str()).c_str());
      m_hTTPSPortHasBeenSet = true;
    }
    XmlNode originProtocolPolicyNode = resultNode.FirstChild("OriginProtocolPolicy");
    if(originProtocolPolicyNode.IsNull())
    {
      originProtocolPolicyNode = resultNode;
    }

    if(!originProtocolPolicyNode.IsNull())
    {
      m_originProtocolPolicy = OriginProtocolPolicyMapper::GetOriginProtocolPolicyForName(StringUtils::Trim(originProtocolPolicyNode.GetText().c_str()).c_str());
      m_originProtocolPolicyHasBeenSet = true;
    }
  }

  return *this;
}
EnvironmentTier& EnvironmentTier::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode nameNode = resultNode.FirstChild("Name");
    if(nameNode.IsNull())
    {
      nameNode = resultNode;
    }

    if(!nameNode.IsNull())
    {
      m_name = StringUtils::Trim(nameNode.GetText().c_str());
      m_nameHasBeenSet = true;
    }
    XmlNode typeNode = resultNode.FirstChild("Type");
    if(typeNode.IsNull())
    {
      typeNode = resultNode;
    }

    if(!typeNode.IsNull())
    {
      m_type = StringUtils::Trim(typeNode.GetText().c_str());
      m_typeHasBeenSet = true;
    }
    XmlNode versionNode = resultNode.FirstChild("Version");
    if(versionNode.IsNull())
    {
      versionNode = resultNode;
    }

    if(!versionNode.IsNull())
    {
      m_version = StringUtils::Trim(versionNode.GetText().c_str());
      m_versionHasBeenSet = true;
    }
  }

  return *this;
}
ClusterSnapshotCopyStatus& ClusterSnapshotCopyStatus::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode destinationRegionNode = resultNode.FirstChild("DestinationRegion");
    if(destinationRegionNode.IsNull())
    {
      destinationRegionNode = resultNode;
    }

    if(!destinationRegionNode.IsNull())
    {
      m_destinationRegion = StringUtils::Trim(destinationRegionNode.GetText().c_str());
      m_destinationRegionHasBeenSet = true;
    }
    XmlNode retentionPeriodNode = resultNode.FirstChild("RetentionPeriod");
    if(retentionPeriodNode.IsNull())
    {
      retentionPeriodNode = resultNode;
    }

    if(!retentionPeriodNode.IsNull())
    {
      m_retentionPeriod = StringUtils::ConvertToInt64(StringUtils::Trim(retentionPeriodNode.GetText().c_str()).c_str());
      m_retentionPeriodHasBeenSet = true;
    }
    XmlNode snapshotCopyGrantNameNode = resultNode.FirstChild("SnapshotCopyGrantName");
    if(snapshotCopyGrantNameNode.IsNull())
    {
      snapshotCopyGrantNameNode = resultNode;
    }

    if(!snapshotCopyGrantNameNode.IsNull())
    {
      m_snapshotCopyGrantName = StringUtils::Trim(snapshotCopyGrantNameNode.GetText().c_str());
      m_snapshotCopyGrantNameHasBeenSet = true;
    }
  }

  return *this;
}
LambdaAction& LambdaAction::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode topicArnNode = resultNode.FirstChild("TopicArn");
    if(topicArnNode.IsNull())
    {
      topicArnNode = resultNode;
    }

    if(!topicArnNode.IsNull())
    {
      m_topicArn = StringUtils::Trim(topicArnNode.GetText().c_str());
      m_topicArnHasBeenSet = true;
    }
    XmlNode functionArnNode = resultNode.FirstChild("FunctionArn");
    if(functionArnNode.IsNull())
    {
      functionArnNode = resultNode;
    }

    if(!functionArnNode.IsNull())
    {
      m_functionArn = StringUtils::Trim(functionArnNode.GetText().c_str());
      m_functionArnHasBeenSet = true;
    }
    XmlNode invocationTypeNode = resultNode.FirstChild("InvocationType");
    if(invocationTypeNode.IsNull())
    {
      invocationTypeNode = resultNode;
    }

    if(!invocationTypeNode.IsNull())
    {
      m_invocationType = InvocationTypeMapper::GetInvocationTypeForName(StringUtils::Trim(invocationTypeNode.GetText().c_str()).c_str());
      m_invocationTypeHasBeenSet = true;
    }
  }

  return *this;
}
Example #21
0
MFADevice& MFADevice::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode userNameNode = resultNode.FirstChild("UserName");
    if(userNameNode.IsNull())
    {
      userNameNode = resultNode;
    }

    if(!userNameNode.IsNull())
    {
      m_userName = StringUtils::Trim(userNameNode.GetText().c_str());
      m_userNameHasBeenSet = true;
    }
    XmlNode serialNumberNode = resultNode.FirstChild("SerialNumber");
    if(serialNumberNode.IsNull())
    {
      serialNumberNode = resultNode;
    }

    if(!serialNumberNode.IsNull())
    {
      m_serialNumber = StringUtils::Trim(serialNumberNode.GetText().c_str());
      m_serialNumberHasBeenSet = true;
    }
    XmlNode enableDateNode = resultNode.FirstChild("EnableDate");
    if(enableDateNode.IsNull())
    {
      enableDateNode = resultNode;
    }

    if(!enableDateNode.IsNull())
    {
      m_enableDate = StringUtils::ConvertToDouble(StringUtils::Trim(enableDateNode.GetText().c_str()).c_str());
      m_enableDateHasBeenSet = true;
    }
  }

  return *this;
}
DescribeDBLogFilesDetails& DescribeDBLogFilesDetails::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode logFileNameNode = resultNode.FirstChild("LogFileName");
    if(logFileNameNode.IsNull())
    {
      logFileNameNode = resultNode;
    }

    if(!logFileNameNode.IsNull())
    {
      m_logFileName = StringUtils::Trim(logFileNameNode.GetText().c_str());
      m_logFileNameHasBeenSet = true;
    }
    XmlNode lastWrittenNode = resultNode.FirstChild("LastWritten");
    if(lastWrittenNode.IsNull())
    {
      lastWrittenNode = resultNode;
    }

    if(!lastWrittenNode.IsNull())
    {
      m_lastWritten = StringUtils::ConvertToInt64(StringUtils::Trim(lastWrittenNode.GetText().c_str()).c_str());
      m_lastWrittenHasBeenSet = true;
    }
    XmlNode sizeNode = resultNode.FirstChild("Size");
    if(sizeNode.IsNull())
    {
      sizeNode = resultNode;
    }

    if(!sizeNode.IsNull())
    {
      m_size = StringUtils::ConvertToInt64(StringUtils::Trim(sizeNode.GetText().c_str()).c_str());
      m_sizeHasBeenSet = true;
    }
  }

  return *this;
}
DomainMembership& DomainMembership::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode domainNode = resultNode.FirstChild("Domain");
    if(domainNode.IsNull())
    {
      domainNode = resultNode;
    }

    if(!domainNode.IsNull())
    {
      m_domain = StringUtils::Trim(domainNode.GetText().c_str());
      m_domainHasBeenSet = true;
    }
    XmlNode statusNode = resultNode.FirstChild("Status");
    if(statusNode.IsNull())
    {
      statusNode = resultNode;
    }

    if(!statusNode.IsNull())
    {
      m_status = StringUtils::Trim(statusNode.GetText().c_str());
      m_statusHasBeenSet = true;
    }
    XmlNode connectivityNode = resultNode.FirstChild("Connectivity");
    if(connectivityNode.IsNull())
    {
      connectivityNode = resultNode;
    }

    if(!connectivityNode.IsNull())
    {
      m_connectivity = StringUtils::Trim(connectivityNode.GetText().c_str());
      m_connectivityHasBeenSet = true;
    }
  }

  return *this;
}
ListHostedZonesResult& ListHostedZonesResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode resultNode = xmlDocument.GetRootElement();

  if(!resultNode.IsNull())
  {
    XmlNode hostedZonesNode = resultNode.FirstChild("HostedZones");
    if(!hostedZonesNode.IsNull())
    {
      XmlNode hostedZonesMember = hostedZonesNode.FirstChild("HostedZone");
      while(!hostedZonesMember.IsNull())
      {
        m_hostedZones.push_back(hostedZonesMember);
        hostedZonesMember = hostedZonesMember.NextNode("HostedZone");
      }

    }
    XmlNode markerNode = resultNode.FirstChild("Marker");
    if(!markerNode.IsNull())
    {
      m_marker = StringUtils::Trim(markerNode.GetText().c_str());
    }
    XmlNode isTruncatedNode = resultNode.FirstChild("IsTruncated");
    if(!isTruncatedNode.IsNull())
    {
      m_isTruncated = StringUtils::ConvertToBool(StringUtils::Trim(isTruncatedNode.GetText().c_str()).c_str());
    }
    XmlNode nextMarkerNode = resultNode.FirstChild("NextMarker");
    if(!nextMarkerNode.IsNull())
    {
      m_nextMarker = StringUtils::Trim(nextMarkerNode.GetText().c_str());
    }
    XmlNode maxItemsNode = resultNode.FirstChild("MaxItems");
    if(!maxItemsNode.IsNull())
    {
      m_maxItems = StringUtils::Trim(maxItemsNode.GetText().c_str());
    }
  }

  return *this;
}
CreateFlowLogsResponse& CreateFlowLogsResponse::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (rootNode.GetName() != "CreateFlowLogsResponse")
  {
    resultNode = rootNode.FirstChild("CreateFlowLogsResponse");
  }

  if(!resultNode.IsNull())
  {
    XmlNode flowLogIdsNode = resultNode.FirstChild("flowLogIdSet");
    if(!flowLogIdsNode.IsNull())
    {
      XmlNode flowLogIdsMember = flowLogIdsNode.FirstChild("item");
      while(!flowLogIdsMember.IsNull())
      {
        m_flowLogIds.push_back(StringUtils::Trim(flowLogIdsMember.GetText().c_str()));
        flowLogIdsMember = flowLogIdsMember.NextNode("item");
      }

    }
    XmlNode clientTokenNode = resultNode.FirstChild("clientToken");
    if(!clientTokenNode.IsNull())
    {
      m_clientToken = StringUtils::Trim(clientTokenNode.GetText().c_str());
    }
    XmlNode unsuccessfulNode = resultNode.FirstChild("unsuccessful");
    if(!unsuccessfulNode.IsNull())
    {
      XmlNode unsuccessfulMember = unsuccessfulNode.FirstChild("item");
      while(!unsuccessfulMember.IsNull())
      {
        m_unsuccessful.push_back(unsuccessfulMember);
        unsuccessfulMember = unsuccessfulMember.NextNode("item");
      }

    }
  }

  XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
  m_responseMetadata = responseMetadataNode;
  AWS_LOGSTREAM_DEBUG("Aws::EC2::Model::CreateFlowLogsResponse", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );

  return *this;
}
DescribeCacheParametersResult& DescribeCacheParametersResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (rootNode.GetName() != "DescribeCacheParametersResult")
  {
    resultNode = rootNode.FirstChild("DescribeCacheParametersResult");
  }

  if(!resultNode.IsNull())
  {
    XmlNode markerNode = resultNode.FirstChild("Marker");
    if(!markerNode.IsNull())
    {
      m_marker = StringUtils::Trim(markerNode.GetText().c_str());
    }
    XmlNode parametersNode = resultNode.FirstChild("Parameters");
    if(!parametersNode.IsNull())
    {
      XmlNode parametersMember = parametersNode.FirstChild("Parameter");
      while(!parametersMember.IsNull())
      {
        m_parameters.push_back(parametersMember);
        parametersMember = parametersMember.NextNode("Parameter");
      }

    }
    XmlNode cacheNodeTypeSpecificParametersNode = resultNode.FirstChild("CacheNodeTypeSpecificParameters");
    if(!cacheNodeTypeSpecificParametersNode.IsNull())
    {
      XmlNode cacheNodeTypeSpecificParametersMember = cacheNodeTypeSpecificParametersNode.FirstChild("CacheNodeTypeSpecificParameter");
      while(!cacheNodeTypeSpecificParametersMember.IsNull())
      {
        m_cacheNodeTypeSpecificParameters.push_back(cacheNodeTypeSpecificParametersMember);
        cacheNodeTypeSpecificParametersMember = cacheNodeTypeSpecificParametersMember.NextNode("CacheNodeTypeSpecificParameter");
      }

    }
  }

  XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
  m_responseMetadata = responseMetadataNode;
  AWS_LOGSTREAM_DEBUG("Aws::ElastiCache::Model::DescribeCacheParametersResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );

  return *this;
}
Example #27
0
S3Location& S3Location::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode s3BucketNode = resultNode.FirstChild("S3Bucket");
    if(!s3BucketNode.IsNull())
    {
      m_s3Bucket = StringUtils::Trim(s3BucketNode.GetText().c_str());
      m_s3BucketHasBeenSet = true;
    }
    XmlNode s3KeyNode = resultNode.FirstChild("S3Key");
    if(!s3KeyNode.IsNull())
    {
      m_s3Key = StringUtils::Trim(s3KeyNode.GetText().c_str());
      m_s3KeyHasBeenSet = true;
    }
  }

  return *this;
}
ApplyEnvironmentManagedActionResult& ApplyEnvironmentManagedActionResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (!rootNode.IsNull() && (rootNode.GetName() != "ApplyEnvironmentManagedActionResult"))
  {
    resultNode = rootNode.FirstChild("ApplyEnvironmentManagedActionResult");
  }

  if(!resultNode.IsNull())
  {
    XmlNode actionIdNode = resultNode.FirstChild("ActionId");
    if(!actionIdNode.IsNull())
    {
      m_actionId = StringUtils::Trim(actionIdNode.GetText().c_str());
    }
    XmlNode actionDescriptionNode = resultNode.FirstChild("ActionDescription");
    if(!actionDescriptionNode.IsNull())
    {
      m_actionDescription = StringUtils::Trim(actionDescriptionNode.GetText().c_str());
    }
    XmlNode actionTypeNode = resultNode.FirstChild("ActionType");
    if(!actionTypeNode.IsNull())
    {
      m_actionType = ActionTypeMapper::GetActionTypeForName(StringUtils::Trim(actionTypeNode.GetText().c_str()).c_str());
    }
    XmlNode statusNode = resultNode.FirstChild("Status");
    if(!statusNode.IsNull())
    {
      m_status = StringUtils::Trim(statusNode.GetText().c_str());
    }
  }

  if (!rootNode.IsNull()) {
    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
    m_responseMetadata = responseMetadataNode;
    AWS_LOGSTREAM_DEBUG("Aws::ElasticBeanstalk::Model::ApplyEnvironmentManagedActionResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
  }
  return *this;
}
Example #29
0
Origin& Origin::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode idNode = resultNode.FirstChild("Id");
    if(!idNode.IsNull())
    {
      m_id = StringUtils::Trim(idNode.GetText().c_str());
      m_idHasBeenSet = true;
    }
    XmlNode domainNameNode = resultNode.FirstChild("DomainName");
    if(!domainNameNode.IsNull())
    {
      m_domainName = StringUtils::Trim(domainNameNode.GetText().c_str());
      m_domainNameHasBeenSet = true;
    }
    XmlNode originPathNode = resultNode.FirstChild("OriginPath");
    if(!originPathNode.IsNull())
    {
      m_originPath = StringUtils::Trim(originPathNode.GetText().c_str());
      m_originPathHasBeenSet = true;
    }
    XmlNode customHeadersNode = resultNode.FirstChild("CustomHeaders");
    if(!customHeadersNode.IsNull())
    {
      m_customHeaders = customHeadersNode;
      m_customHeadersHasBeenSet = true;
    }
    XmlNode s3OriginConfigNode = resultNode.FirstChild("S3OriginConfig");
    if(!s3OriginConfigNode.IsNull())
    {
      m_s3OriginConfig = s3OriginConfigNode;
      m_s3OriginConfigHasBeenSet = true;
    }
    XmlNode customOriginConfigNode = resultNode.FirstChild("CustomOriginConfig");
    if(!customOriginConfigNode.IsNull())
    {
      m_customOriginConfig = customOriginConfigNode;
      m_customOriginConfigHasBeenSet = true;
    }
  }

  return *this;
}
Example #30
0
ExportTask& ExportTask::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode exportTaskIdNode = resultNode.FirstChild("exportTaskId");
    if(!exportTaskIdNode.IsNull())
    {
      m_exportTaskId = StringUtils::Trim(exportTaskIdNode.GetText().c_str());
      m_exportTaskIdHasBeenSet = true;
    }
    XmlNode descriptionNode = resultNode.FirstChild("description");
    if(!descriptionNode.IsNull())
    {
      m_description = StringUtils::Trim(descriptionNode.GetText().c_str());
      m_descriptionHasBeenSet = true;
    }
    XmlNode stateNode = resultNode.FirstChild("state");
    if(!stateNode.IsNull())
    {
      m_state = ExportTaskStateMapper::GetExportTaskStateForName(StringUtils::Trim(stateNode.GetText().c_str()).c_str());
      m_stateHasBeenSet = true;
    }
    XmlNode statusMessageNode = resultNode.FirstChild("statusMessage");
    if(!statusMessageNode.IsNull())
    {
      m_statusMessage = StringUtils::Trim(statusMessageNode.GetText().c_str());
      m_statusMessageHasBeenSet = true;
    }
    XmlNode instanceExportDetailsNode = resultNode.FirstChild("instanceExport");
    if(!instanceExportDetailsNode.IsNull())
    {
      m_instanceExportDetails = instanceExportDetailsNode;
      m_instanceExportDetailsHasBeenSet = true;
    }
    XmlNode exportToS3TaskNode = resultNode.FirstChild("exportToS3");
    if(!exportToS3TaskNode.IsNull())
    {
      m_exportToS3Task = exportToS3TaskNode;
      m_exportToS3TaskHasBeenSet = true;
    }
  }

  return *this;
}