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

  if(!resultNode.IsNull())
  {
    XmlNode spotFleetRequestIdNode = resultNode.FirstChild("spotFleetRequestId");
    if(!spotFleetRequestIdNode.IsNull())
    {
      m_spotFleetRequestId = StringUtils::Trim(spotFleetRequestIdNode.GetText().c_str());
    }
    XmlNode activeInstancesNode = resultNode.FirstChild("activeInstanceSet");
    if(!activeInstancesNode.IsNull())
    {
      XmlNode activeInstancesMember = activeInstancesNode.FirstChild("item");
      while(!activeInstancesMember.IsNull())
      {
        m_activeInstances.push_back(activeInstancesMember);
        activeInstancesMember = activeInstancesMember.NextNode("item");
      }

    }
    XmlNode nextTokenNode = resultNode.FirstChild("nextToken");
    if(!nextTokenNode.IsNull())
    {
      m_nextToken = StringUtils::Trim(nextTokenNode.GetText().c_str());
    }
  }

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

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

  if(!resultNode.IsNull())
  {
    XmlNode policyNamesNode = resultNode.FirstChild("PolicyNames");
    if(!policyNamesNode.IsNull())
    {
      XmlNode policyNamesMember = policyNamesNode.FirstChild("member");
      while(!policyNamesMember.IsNull())
      {
        m_policyNames.push_back(StringUtils::Trim(policyNamesMember.GetText().c_str()));
        policyNamesMember = policyNamesMember.NextNode("member");
      }

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

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

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

  if(!resultNode.IsNull())
  {
    XmlNode cacheSubnetGroupNameNode = resultNode.FirstChild("CacheSubnetGroupName");
    if(!cacheSubnetGroupNameNode.IsNull())
    {
      m_cacheSubnetGroupName = StringUtils::Trim(cacheSubnetGroupNameNode.GetText().c_str());
      m_cacheSubnetGroupNameHasBeenSet = true;
    }
    XmlNode cacheSubnetGroupDescriptionNode = resultNode.FirstChild("CacheSubnetGroupDescription");
    if(!cacheSubnetGroupDescriptionNode.IsNull())
    {
      m_cacheSubnetGroupDescription = StringUtils::Trim(cacheSubnetGroupDescriptionNode.GetText().c_str());
      m_cacheSubnetGroupDescriptionHasBeenSet = true;
    }
    XmlNode vpcIdNode = resultNode.FirstChild("VpcId");
    if(!vpcIdNode.IsNull())
    {
      m_vpcId = StringUtils::Trim(vpcIdNode.GetText().c_str());
      m_vpcIdHasBeenSet = true;
    }
    XmlNode subnetsNode = resultNode.FirstChild("Subnets");
    if(!subnetsNode.IsNull())
    {
      XmlNode subnetsMember = subnetsNode.FirstChild("Subnet");
      while(!subnetsMember.IsNull())
      {
        m_subnets.push_back(subnetsMember);
        subnetsMember = subnetsMember.NextNode("Subnet");
      }

      m_subnetsHasBeenSet = true;
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode instanceHealthListNode = resultNode.FirstChild("InstanceHealthList");
    if(!instanceHealthListNode.IsNull())
    {
      XmlNode instanceHealthListMember = instanceHealthListNode.FirstChild("member");
      while(!instanceHealthListMember.IsNull())
      {
        m_instanceHealthList.push_back(instanceHealthListMember);
        instanceHealthListMember = instanceHealthListMember.NextNode("member");
      }

    }
    XmlNode refreshedAtNode = resultNode.FirstChild("RefreshedAt");
    if(!refreshedAtNode.IsNull())
    {
      m_refreshedAt = StringUtils::ConvertToDouble(StringUtils::Trim(refreshedAtNode.GetText().c_str()).c_str());
    }
    XmlNode nextTokenNode = resultNode.FirstChild("NextToken");
    if(!nextTokenNode.IsNull())
    {
      m_nextToken = StringUtils::Trim(nextTokenNode.GetText().c_str());
    }
  }

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

  return *this;
}
CloudFunctionConfiguration& CloudFunctionConfiguration::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 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 cloudFunctionNode = resultNode.FirstChild("CloudFunction");
    if(!cloudFunctionNode.IsNull())
    {
      m_cloudFunction = StringUtils::Trim(cloudFunctionNode.GetText().c_str());
      m_cloudFunctionHasBeenSet = true;
    }
    XmlNode invocationRoleNode = resultNode.FirstChild("InvocationRole");
    if(!invocationRoleNode.IsNull())
    {
      m_invocationRole = StringUtils::Trim(invocationRoleNode.GetText().c_str());
      m_invocationRoleHasBeenSet = true;
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode networkInterfacePermissionsNode = resultNode.FirstChild("networkInterfacePermissions");
    if(!networkInterfacePermissionsNode.IsNull())
    {
      XmlNode networkInterfacePermissionsMember = networkInterfacePermissionsNode.FirstChild("item");
      while(!networkInterfacePermissionsMember.IsNull())
      {
        m_networkInterfacePermissions.push_back(networkInterfacePermissionsMember);
        networkInterfacePermissionsMember = networkInterfacePermissionsMember.NextNode("item");
      }

    }
    XmlNode nextTokenNode = resultNode.FirstChild("nextToken");
    if(!nextTokenNode.IsNull())
    {
      m_nextToken = StringUtils::Trim(nextTokenNode.GetText().c_str());
    }
  }

  if (!rootNode.IsNull()) {
    XmlNode requestIdNode = rootNode.FirstChild("requestId");
    if (!requestIdNode.IsNull())
    {
      m_responseMetadata.SetRequestId(StringUtils::Trim(requestIdNode.GetText().c_str()));
    }
    AWS_LOGSTREAM_DEBUG("Aws::EC2::Model::DescribeNetworkInterfacePermissionsResponse", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
  }
  return *this;
}
PendingModifiedValues& PendingModifiedValues::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode numCacheNodesNode = resultNode.FirstChild("NumCacheNodes");
    if(!numCacheNodesNode.IsNull())
    {
      m_numCacheNodes = StringUtils::ConvertToInt32(StringUtils::Trim(numCacheNodesNode.GetText().c_str()).c_str());
      m_numCacheNodesHasBeenSet = true;
    }
    XmlNode cacheNodeIdsToRemoveNode = resultNode.FirstChild("CacheNodeIdsToRemove");
    if(!cacheNodeIdsToRemoveNode.IsNull())
    {
      XmlNode cacheNodeIdsToRemoveMember = cacheNodeIdsToRemoveNode.FirstChild("CacheNodeId");
      while(!cacheNodeIdsToRemoveMember.IsNull())
      {
        m_cacheNodeIdsToRemove.push_back(StringUtils::Trim(cacheNodeIdsToRemoveMember.GetText().c_str()));
        cacheNodeIdsToRemoveMember = cacheNodeIdsToRemoveMember.NextNode("CacheNodeId");
      }

      m_cacheNodeIdsToRemoveHasBeenSet = true;
    }
    XmlNode engineVersionNode = resultNode.FirstChild("EngineVersion");
    if(!engineVersionNode.IsNull())
    {
      m_engineVersion = StringUtils::Trim(engineVersionNode.GetText().c_str());
      m_engineVersionHasBeenSet = true;
    }
    XmlNode cacheNodeTypeNode = resultNode.FirstChild("CacheNodeType");
    if(!cacheNodeTypeNode.IsNull())
    {
      m_cacheNodeType = StringUtils::Trim(cacheNodeTypeNode.GetText().c_str());
      m_cacheNodeTypeHasBeenSet = true;
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode errorDocumentNode = resultNode.FirstChild("ErrorDocument");
    if(!errorDocumentNode.IsNull())
    {
      m_errorDocument = errorDocumentNode;
      m_errorDocumentHasBeenSet = true;
    }
    XmlNode indexDocumentNode = resultNode.FirstChild("IndexDocument");
    if(!indexDocumentNode.IsNull())
    {
      m_indexDocument = indexDocumentNode;
      m_indexDocumentHasBeenSet = true;
    }
    XmlNode redirectAllRequestsToNode = resultNode.FirstChild("RedirectAllRequestsTo");
    if(!redirectAllRequestsToNode.IsNull())
    {
      m_redirectAllRequestsTo = redirectAllRequestsToNode;
      m_redirectAllRequestsToHasBeenSet = true;
    }
    XmlNode routingRulesNode = resultNode.FirstChild("RoutingRules");
    if(!routingRulesNode.IsNull())
    {
      XmlNode routingRulesMember = routingRulesNode.FirstChild("RoutingRule");
      while(!routingRulesMember.IsNull())
      {
        m_routingRules.push_back(routingRulesMember);
        routingRulesMember = routingRulesMember.NextNode("RoutingRule");
      }

      m_routingRulesHasBeenSet = true;
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode clusterVersionNode = resultNode.FirstChild("ClusterVersion");
    if(!clusterVersionNode.IsNull())
    {
      m_clusterVersion = StringUtils::Trim(clusterVersionNode.GetText().c_str());
      m_clusterVersionHasBeenSet = true;
    }
    XmlNode clusterTypeNode = resultNode.FirstChild("ClusterType");
    if(!clusterTypeNode.IsNull())
    {
      m_clusterType = StringUtils::Trim(clusterTypeNode.GetText().c_str());
      m_clusterTypeHasBeenSet = true;
    }
    XmlNode nodeTypeNode = resultNode.FirstChild("NodeType");
    if(!nodeTypeNode.IsNull())
    {
      m_nodeType = StringUtils::Trim(nodeTypeNode.GetText().c_str());
      m_nodeTypeHasBeenSet = true;
    }
    XmlNode availabilityZonesNode = resultNode.FirstChild("AvailabilityZones");
    if(!availabilityZonesNode.IsNull())
    {
      XmlNode availabilityZonesMember = availabilityZonesNode.FirstChild("AvailabilityZone");
      while(!availabilityZonesMember.IsNull())
      {
        m_availabilityZones.push_back(availabilityZonesMember);
        availabilityZonesMember = availabilityZonesMember.NextNode("AvailabilityZone");
      }

      m_availabilityZonesHasBeenSet = true;
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode virtualMFADevicesNode = resultNode.FirstChild("VirtualMFADevices");
    if(!virtualMFADevicesNode.IsNull())
    {
      XmlNode virtualMFADevicesMember = virtualMFADevicesNode.FirstChild("member");
      while(!virtualMFADevicesMember.IsNull())
      {
        m_virtualMFADevices.push_back(virtualMFADevicesMember);
        virtualMFADevicesMember = virtualMFADevicesMember.NextNode("member");
      }

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

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

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

  if(!resultNode.IsNull())
  {
    XmlNode zoneNameNode = resultNode.FirstChild("zoneName");
    if(!zoneNameNode.IsNull())
    {
      m_zoneName = StringUtils::Trim(zoneNameNode.GetText().c_str());
      m_zoneNameHasBeenSet = true;
    }
    XmlNode stateNode = resultNode.FirstChild("zoneState");
    if(!stateNode.IsNull())
    {
      m_state = AvailabilityZoneStateMapper::GetAvailabilityZoneStateForName(StringUtils::Trim(stateNode.GetText().c_str()).c_str());
      m_stateHasBeenSet = true;
    }
    XmlNode regionNameNode = resultNode.FirstChild("regionName");
    if(!regionNameNode.IsNull())
    {
      m_regionName = StringUtils::Trim(regionNameNode.GetText().c_str());
      m_regionNameHasBeenSet = true;
    }
    XmlNode messagesNode = resultNode.FirstChild("messageSet");
    if(!messagesNode.IsNull())
    {
      XmlNode messagesMember = messagesNode.FirstChild("item");
      while(!messagesMember.IsNull())
      {
        m_messages.push_back(messagesMember);
        messagesMember = messagesMember.NextNode("item");
      }

      m_messagesHasBeenSet = true;
    }
  }

  return *this;
}
示例#12
0
MetricDataBatch& MetricDataBatch::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode accountIdNode = resultNode.FirstChild("AccountId");
    if(!accountIdNode.IsNull())
    {
      m_accountId = StringUtils::Trim(accountIdNode.GetText().c_str());
      m_accountIdHasBeenSet = true;
    }
    XmlNode namespaceNode = resultNode.FirstChild("Namespace");
    if(!namespaceNode.IsNull())
    {
      m_namespace = StringUtils::Trim(namespaceNode.GetText().c_str());
      m_namespaceHasBeenSet = true;
    }
    XmlNode metricDataNode = resultNode.FirstChild("MetricData");
    if(!metricDataNode.IsNull())
    {
      XmlNode metricDataMember = metricDataNode.FirstChild("member");
      while(!metricDataMember.IsNull())
      {
        m_metricData.push_back(metricDataMember);
        metricDataMember = metricDataMember.NextNode("member");
      }

      m_metricDataHasBeenSet = true;
    }
    XmlNode autoDecomposeNode = resultNode.FirstChild("AutoDecompose");
    if(!autoDecomposeNode.IsNull())
    {
      m_autoDecompose = StringUtils::ConvertToBool(StringUtils::Trim(autoDecomposeNode.GetText().c_str()).c_str());
      m_autoDecomposeHasBeenSet = true;
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode parameterGroupNameNode = resultNode.FirstChild("ParameterGroupName");
    if(!parameterGroupNameNode.IsNull())
    {
      m_parameterGroupName = StringUtils::Trim(parameterGroupNameNode.GetText().c_str());
      m_parameterGroupNameHasBeenSet = true;
    }
    XmlNode parameterGroupFamilyNode = resultNode.FirstChild("ParameterGroupFamily");
    if(!parameterGroupFamilyNode.IsNull())
    {
      m_parameterGroupFamily = StringUtils::Trim(parameterGroupFamilyNode.GetText().c_str());
      m_parameterGroupFamilyHasBeenSet = true;
    }
    XmlNode descriptionNode = resultNode.FirstChild("Description");
    if(!descriptionNode.IsNull())
    {
      m_description = StringUtils::Trim(descriptionNode.GetText().c_str());
      m_descriptionHasBeenSet = true;
    }
    XmlNode tagsNode = resultNode.FirstChild("Tags");
    if(!tagsNode.IsNull())
    {
      XmlNode tagsMember = tagsNode.FirstChild("Tag");
      while(!tagsMember.IsNull())
      {
        m_tags.push_back(tagsMember);
        tagsMember = tagsMember.NextNode("Tag");
      }

      m_tagsHasBeenSet = true;
    }
  }

  return *this;
}
示例#14
0
QueueConfiguration& QueueConfiguration::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 queueArnNode = resultNode.FirstChild("Queue");
        if(!queueArnNode.IsNull())
        {
            m_queueArn = StringUtils::Trim(queueArnNode.GetText().c_str());
            m_queueArnHasBeenSet = 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 filterNode = resultNode.FirstChild("Filter");
        if(!filterNode.IsNull())
        {
            m_filter = filterNode;
            m_filterHasBeenSet = true;
        }
    }

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

  if(!resultNode.IsNull())
  {
    XmlNode volumesNode = resultNode.FirstChild("volumes");
    if(!volumesNode.IsNull())
    {
      XmlNode volumesMember = volumesNode.FirstChild("item");
      while(!volumesMember.IsNull())
      {
        m_volumes.push_back(volumesMember);
        volumesMember = volumesMember.NextNode("item");
      }

      m_volumesHasBeenSet = true;
    }
    XmlNode instanceIdNode = resultNode.FirstChild("instanceId");
    if(!instanceIdNode.IsNull())
    {
      m_instanceId = StringUtils::Trim(instanceIdNode.GetText().c_str());
      m_instanceIdHasBeenSet = true;
    }
    XmlNode platformNode = resultNode.FirstChild("platform");
    if(!platformNode.IsNull())
    {
      m_platform = PlatformValuesMapper::GetPlatformValuesForName(StringUtils::Trim(platformNode.GetText().c_str()).c_str());
      m_platformHasBeenSet = true;
    }
    XmlNode descriptionNode = resultNode.FirstChild("description");
    if(!descriptionNode.IsNull())
    {
      m_description = StringUtils::Trim(descriptionNode.GetText().c_str());
      m_descriptionHasBeenSet = true;
    }
  }

  return *this;
}
示例#16
0
EventInfoMap& EventInfoMap::operator =(const XmlNode& xmlNode)
{
    XmlNode resultNode = xmlNode;

    if(!resultNode.IsNull())
    {
        XmlNode eventIdNode = resultNode.FirstChild("EventId");
        if(!eventIdNode.IsNull())
        {
            m_eventId = StringUtils::Trim(eventIdNode.GetText().c_str());
            m_eventIdHasBeenSet = true;
        }
        XmlNode eventCategoriesNode = resultNode.FirstChild("EventCategories");
        if(!eventCategoriesNode.IsNull())
        {
            XmlNode eventCategoriesMember = eventCategoriesNode.FirstChild("EventCategory");
            while(!eventCategoriesMember.IsNull())
            {
                m_eventCategories.push_back(StringUtils::Trim(eventCategoriesMember.GetText().c_str()));
                eventCategoriesMember = eventCategoriesMember.NextNode("EventCategory");
            }

            m_eventCategoriesHasBeenSet = true;
        }
        XmlNode eventDescriptionNode = resultNode.FirstChild("EventDescription");
        if(!eventDescriptionNode.IsNull())
        {
            m_eventDescription = StringUtils::Trim(eventDescriptionNode.GetText().c_str());
            m_eventDescriptionHasBeenSet = true;
        }
        XmlNode severityNode = resultNode.FirstChild("Severity");
        if(!severityNode.IsNull())
        {
            m_severity = StringUtils::Trim(severityNode.GetText().c_str());
            m_severityHasBeenSet = true;
        }
    }

    return *this;
}
示例#17
0
S3KeyFilter& S3KeyFilter::operator =(const XmlNode& xmlNode)
{
    XmlNode resultNode = xmlNode;

    if(!resultNode.IsNull())
    {
        XmlNode filterRulesNode = resultNode.FirstChild("FilterRules");
        if(!filterRulesNode.IsNull())
        {
            XmlNode filterRulesMember = filterRulesNode;
            while(!filterRulesMember.IsNull())
            {
                m_filterRules.push_back(filterRulesMember);
                filterRulesMember = filterRulesMember.NextNode("FilterRule");
            }

            m_filterRulesHasBeenSet = true;
        }
    }

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

  if(!resultNode.IsNull())
  {
    XmlNode tagSetNode = resultNode.FirstChild("TagSet");
    if(!tagSetNode.IsNull())
    {
      XmlNode tagSetMember = tagSetNode.FirstChild("Tag");
      while(!tagSetMember.IsNull())
      {
        m_tagSet.push_back(tagSetMember);
        tagSetMember = tagSetMember.NextNode("Tag");
      }

    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode checkerIpRangesNode = resultNode.FirstChild("CheckerIpRanges");
    if(!checkerIpRangesNode.IsNull())
    {
      XmlNode checkerIpRangesMember = checkerIpRangesNode.FirstChild("member");
      while(!checkerIpRangesMember.IsNull())
      {
        m_checkerIpRanges.push_back(StringUtils::Trim(checkerIpRangesMember.GetText().c_str()));
        checkerIpRangesMember = checkerIpRangesMember.NextNode("member");
      }

    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode healthCheckObservationsNode = resultNode.FirstChild("HealthCheckObservations");
    if(!healthCheckObservationsNode.IsNull())
    {
      XmlNode healthCheckObservationsMember = healthCheckObservationsNode.FirstChild("HealthCheckObservation");
      while(!healthCheckObservationsMember.IsNull())
      {
        m_healthCheckObservations.push_back(healthCheckObservationsMember);
        healthCheckObservationsMember = healthCheckObservationsMember.NextNode("HealthCheckObservation");
      }

    }
  }

  return *this;
}
示例#21
0
CORSConfiguration& CORSConfiguration::operator =(const XmlNode& xmlNode)
{
  XmlNode resultNode = xmlNode;

  if(!resultNode.IsNull())
  {
    XmlNode cORSRulesNode = resultNode.FirstChild("CORSRules");
    if(!cORSRulesNode.IsNull())
    {
      XmlNode cORSRulesMember = cORSRulesNode;
      while(!cORSRulesMember.IsNull())
      {
        m_cORSRules.push_back(cORSRulesMember);
        cORSRulesMember = cORSRulesMember.NextNode("CORSRule");
      }

      m_cORSRulesHasBeenSet = true;
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode cORSRulesNode = resultNode.FirstChild("CORSRules");
    if(!cORSRulesNode.IsNull())
    {
      XmlNode cORSRulesMember = cORSRulesNode;
      while(!cORSRulesMember.IsNull())
      {
        m_cORSRules.push_back(cORSRulesMember);
        cORSRulesMember = cORSRulesMember.NextNode("CORSRule");
      }

    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode partsNode = resultNode.FirstChild("Part");
    if(!partsNode.IsNull())
    {
      XmlNode partMember = partsNode;
      while(!partMember.IsNull())
      {
        m_parts.push_back(partMember);
        partMember = partMember.NextNode("Part");
      }

      m_partsHasBeenSet = true;
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode redirectAllRequestsToNode = resultNode.FirstChild("RedirectAllRequestsTo");
    if(!redirectAllRequestsToNode.IsNull())
    {
      m_redirectAllRequestsTo = redirectAllRequestsToNode;
    }
    XmlNode indexDocumentNode = resultNode.FirstChild("IndexDocument");
    if(!indexDocumentNode.IsNull())
    {
      m_indexDocument = indexDocumentNode;
    }
    XmlNode errorDocumentNode = resultNode.FirstChild("ErrorDocument");
    if(!errorDocumentNode.IsNull())
    {
      m_errorDocument = errorDocumentNode;
    }
    XmlNode routingRulesNode = resultNode.FirstChild("RoutingRules");
    if(!routingRulesNode.IsNull())
    {
      XmlNode routingRulesMember = routingRulesNode.FirstChild("RoutingRule");
      while(!routingRulesMember.IsNull())
      {
        m_routingRules.push_back(routingRulesMember);
        routingRulesMember = routingRulesMember.NextNode("RoutingRule");
      }

    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode autoScalingGroupsNode = resultNode.FirstChild("AutoScalingGroups");
    if(!autoScalingGroupsNode.IsNull())
    {
      XmlNode autoScalingGroupsMember = autoScalingGroupsNode.FirstChild("member");
      while(!autoScalingGroupsMember.IsNull())
      {
        m_autoScalingGroups.push_back(autoScalingGroupsMember);
        autoScalingGroupsMember = autoScalingGroupsMember.NextNode("member");
      }

    }
    XmlNode nextTokenNode = resultNode.FirstChild("NextToken");
    if(!nextTokenNode.IsNull())
    {
      m_nextToken = StringUtils::Trim(nextTokenNode.GetText().c_str());
    }
  }

  if (!rootNode.IsNull()) {
    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
    m_responseMetadata = responseMetadataNode;
    AWS_LOGSTREAM_DEBUG("Aws::AutoScaling::Model::DescribeAutoScalingGroupsResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
  }
  return *this;
}
DescribeAccountLimitsResult& DescribeAccountLimitsResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (!rootNode.IsNull() && (rootNode.GetName() != "DescribeAccountLimitsResult"))
  {
    resultNode = rootNode.FirstChild("DescribeAccountLimitsResult");
  }

  if(!resultNode.IsNull())
  {
    XmlNode limitsNode = resultNode.FirstChild("Limits");
    if(!limitsNode.IsNull())
    {
      XmlNode limitsMember = limitsNode.FirstChild("member");
      while(!limitsMember.IsNull())
      {
        m_limits.push_back(limitsMember);
        limitsMember = limitsMember.NextNode("member");
      }

    }
    XmlNode nextMarkerNode = resultNode.FirstChild("NextMarker");
    if(!nextMarkerNode.IsNull())
    {
      m_nextMarker = StringUtils::Trim(nextMarkerNode.GetText().c_str());
    }
  }

  if (!rootNode.IsNull()) {
    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
    m_responseMetadata = responseMetadataNode;
    AWS_LOGSTREAM_DEBUG("Aws::ElasticLoadBalancing::Model::DescribeAccountLimitsResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
  }
  return *this;
}
ListBucketInventoryConfigurationsResult& ListBucketInventoryConfigurationsResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode resultNode = xmlDocument.GetRootElement();

  if(!resultNode.IsNull())
  {
    XmlNode continuationTokenNode = resultNode.FirstChild("ContinuationToken");
    if(!continuationTokenNode.IsNull())
    {
      m_continuationToken = StringUtils::Trim(continuationTokenNode.GetText().c_str());
    }
    XmlNode inventoryConfigurationListNode = resultNode.FirstChild("InventoryConfiguration");
    if(!inventoryConfigurationListNode.IsNull())
    {
      XmlNode inventoryConfigurationMember = inventoryConfigurationListNode;
      while(!inventoryConfigurationMember.IsNull())
      {
        m_inventoryConfigurationList.push_back(inventoryConfigurationMember);
        inventoryConfigurationMember = inventoryConfigurationMember.NextNode("InventoryConfiguration");
      }

    }
    XmlNode isTruncatedNode = resultNode.FirstChild("IsTruncated");
    if(!isTruncatedNode.IsNull())
    {
      m_isTruncated = StringUtils::ConvertToBool(StringUtils::Trim(isTruncatedNode.GetText().c_str()).c_str());
    }
    XmlNode nextContinuationTokenNode = resultNode.FirstChild("NextContinuationToken");
    if(!nextContinuationTokenNode.IsNull())
    {
      m_nextContinuationToken = StringUtils::Trim(nextContinuationTokenNode.GetText().c_str());
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode platformApplicationArnNode = resultNode.FirstChild("PlatformApplicationArn");
    if(platformApplicationArnNode.IsNull())
    {
      platformApplicationArnNode = resultNode;
    }

    if(!platformApplicationArnNode.IsNull())
    {
      m_platformApplicationArn = StringUtils::Trim(platformApplicationArnNode.GetText().c_str());
      m_platformApplicationArnHasBeenSet = true;
    }
    XmlNode attributesNode = resultNode.FirstChild("Attributes");

    if(!attributesNode.IsNull())
    {
      XmlNode attributesEntry = attributesNode.FirstChild("entry");
      while(!attributesEntry.IsNull())
      {
        XmlNode keyNode = attributesEntry.FirstChild("key");
        XmlNode valueNode = attributesEntry.FirstChild("value");
        m_attributes[StringUtils::Trim(keyNode.GetText().c_str())] =
            StringUtils::Trim(valueNode.GetText().c_str());
        attributesEntry = attributesEntry.NextNode("entry");
      }

      m_attributesHasBeenSet = true;
    }
  }

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

  if(!resultNode.IsNull())
  {
    XmlNode domainNamesNode = resultNode.FirstChild("DomainNames");

    if(!domainNamesNode.IsNull())
    {
      XmlNode domainNamesEntry = domainNamesNode.FirstChild("entry");
      while(!domainNamesEntry.IsNull())
      {
        XmlNode keyNode = domainNamesEntry.FirstChild("key");
        XmlNode valueNode = domainNamesEntry.FirstChild("value");
        m_domainNames[StringUtils::Trim(keyNode.GetText().c_str())] =
            StringUtils::Trim(valueNode.GetText().c_str());
        domainNamesEntry = domainNamesEntry.NextNode("entry");
      }

    }
  }

  if (!rootNode.IsNull()) {
    XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
    m_responseMetadata = responseMetadataNode;
    AWS_LOGSTREAM_DEBUG("Aws::CloudSearch::Model::ListDomainNamesResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
  }
  return *this;
}
ListExportsResult& ListExportsResult::operator =(const AmazonWebServiceResult<XmlDocument>& result)
{
  const XmlDocument& xmlDocument = result.GetPayload();
  XmlNode rootNode = xmlDocument.GetRootElement();
  XmlNode resultNode = rootNode;
  if (rootNode.GetName() != "ListExportsResult")
  {
    resultNode = rootNode.FirstChild("ListExportsResult");
  }

  if(!resultNode.IsNull())
  {
    XmlNode exportsNode = resultNode.FirstChild("Exports");
    if(!exportsNode.IsNull())
    {
      XmlNode exportsMember = exportsNode.FirstChild("member");
      while(!exportsMember.IsNull())
      {
        m_exports.push_back(exportsMember);
        exportsMember = exportsMember.NextNode("member");
      }

    }
    XmlNode nextTokenNode = resultNode.FirstChild("NextToken");
    if(!nextTokenNode.IsNull())
    {
      m_nextToken = StringUtils::Trim(nextTokenNode.GetText().c_str());
    }
  }

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

  return *this;
}