public StackSummary Unmarshall(UnmarshallerContext context)
        {
            StackSummary stackSummary  = new StackSummary();
            int          originalDepth = context.CurrentDepth;
            int          targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("StackId", targetDepth))
                    {
                        stackSummary.StackId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("StackName", targetDepth))
                    {
                        stackSummary.StackName = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("TemplateDescription", targetDepth))
                    {
                        stackSummary.TemplateDescription = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("CreationTime", targetDepth))
                    {
                        stackSummary.CreationTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("DeletionTime", targetDepth))
                    {
                        stackSummary.DeletionTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("StackStatus", targetDepth))
                    {
                        stackSummary.StackStatus = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(stackSummary);
                }
            }

            return(stackSummary);
        }
        public JobFlowExecutionStatusDetail Unmarshall(UnmarshallerContext context)
        {
            JobFlowExecutionStatusDetail jobFlowExecutionStatusDetail = new JobFlowExecutionStatusDetail();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("State", targetDepth))
                    {
                        jobFlowExecutionStatusDetail.State = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("CreationDateTime", targetDepth))
                    {
                        jobFlowExecutionStatusDetail.CreationDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("StartDateTime", targetDepth))
                    {
                        jobFlowExecutionStatusDetail.StartDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("ReadyDateTime", targetDepth))
                    {
                        jobFlowExecutionStatusDetail.ReadyDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("EndDateTime", targetDepth))
                    {
                        jobFlowExecutionStatusDetail.EndDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("LastStateChangeReason", targetDepth))
                    {
                        jobFlowExecutionStatusDetail.LastStateChangeReason = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(jobFlowExecutionStatusDetail);
                }
            }

            return(jobFlowExecutionStatusDetail);
        }
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            DescribeIdentityResponse describeIdentityResponse = new DescribeIdentityResponse();

            context.Read();
            int currentDepth = context.CurrentDepth;

            while (context.ReadAtDepth(currentDepth))
            {
                if (context.TestExpression("CreationDate", currentDepth))
                {
                    DateTimeUnmarshaller instance = DateTimeUnmarshaller.Instance;
                    describeIdentityResponse.CreationDate = instance.Unmarshall(context);
                }
                else if (context.TestExpression("IdentityId", currentDepth))
                {
                    StringUnmarshaller instance2 = StringUnmarshaller.Instance;
                    describeIdentityResponse.IdentityId = instance2.Unmarshall(context);
                }
                else if (context.TestExpression("LastModifiedDate", currentDepth))
                {
                    DateTimeUnmarshaller instance3 = DateTimeUnmarshaller.Instance;
                    describeIdentityResponse.LastModifiedDate = instance3.Unmarshall(context);
                }
                else if (context.TestExpression("Logins", currentDepth))
                {
                    ListUnmarshaller <string, StringUnmarshaller> listUnmarshaller = new ListUnmarshaller <string, StringUnmarshaller>(StringUnmarshaller.Instance);
                    describeIdentityResponse.Logins = listUnmarshaller.Unmarshall(context);
                }
            }
            return(describeIdentityResponse);
        }
        public StackResourceSummary Unmarshall(UnmarshallerContext context)
        {
            StackResourceSummary stackResourceSummary = new StackResourceSummary();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("LogicalResourceId", targetDepth))
                    {
                        stackResourceSummary.LogicalResourceId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("PhysicalResourceId", targetDepth))
                    {
                        stackResourceSummary.PhysicalResourceId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("ResourceType", targetDepth))
                    {
                        stackResourceSummary.ResourceType = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("LastUpdatedTimestamp", targetDepth))
                    {
                        stackResourceSummary.LastUpdatedTimestamp = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("ResourceStatus", targetDepth))
                    {
                        stackResourceSummary.ResourceStatus = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("ResourceStatusReason", targetDepth))
                    {
                        stackResourceSummary.ResourceStatusReason = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(stackResourceSummary);
                }
            }

            return(stackResourceSummary);
        }
Example #5
0
        public WorkflowExecutionDetail Unmarshall(JsonUnmarshallerContext context)
        {
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }

            WorkflowExecutionDetail workflowExecutionDetail = new WorkflowExecutionDetail();



            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            while (context.Read())
            {
                if (context.TestExpression("executionInfo", targetDepth))
                {
                    context.Read();
                    workflowExecutionDetail.ExecutionInfo = WorkflowExecutionInfoUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("executionConfiguration", targetDepth))
                {
                    context.Read();
                    workflowExecutionDetail.ExecutionConfiguration = WorkflowExecutionConfigurationUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("openCounts", targetDepth))
                {
                    context.Read();
                    workflowExecutionDetail.OpenCounts = WorkflowExecutionOpenCountsUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("latestActivityTaskTimestamp", targetDepth))
                {
                    context.Read();
                    workflowExecutionDetail.LatestActivityTaskTimestamp = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("latestExecutionContext", targetDepth))
                {
                    context.Read();
                    workflowExecutionDetail.LatestExecutionContext = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.CurrentDepth <= originalDepth)
                {
                    return(workflowExecutionDetail);
                }
            }


            return(workflowExecutionDetail);
        }
Example #6
0
        public ActivityTypeInfo Unmarshall(JsonUnmarshallerContext context)
        {
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }

            ActivityTypeInfo activityTypeInfo = new ActivityTypeInfo();



            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            while (context.Read())
            {
                if (context.TestExpression("activityType", targetDepth))
                {
                    context.Read();
                    activityTypeInfo.ActivityType = ActivityTypeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("status", targetDepth))
                {
                    context.Read();
                    activityTypeInfo.Status = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("description", targetDepth))
                {
                    context.Read();
                    activityTypeInfo.Description = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("creationDate", targetDepth))
                {
                    context.Read();
                    activityTypeInfo.CreationDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("deprecationDate", targetDepth))
                {
                    context.Read();
                    activityTypeInfo.DeprecationDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.CurrentDepth <= originalDepth)
                {
                    return(activityTypeInfo);
                }
            }


            return(activityTypeInfo);
        }
        public LifecycleTransition Unmarshall(XmlUnmarshallerContext context)
        {
            LifecycleTransition lifecycleTransition = new LifecycleTransition();
            int currentDepth = context.get_CurrentDepth();
            int num          = currentDepth + 1;

            if (context.get_IsStartOfDocument())
            {
                num += 2;
            }
            while (context.Read())
            {
                if (context.get_IsStartElement() || context.get_IsAttribute())
                {
                    if (context.TestExpression("Date", num))
                    {
                        lifecycleTransition.Date = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("Days", num))
                    {
                        lifecycleTransition.Days = IntUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("StorageClass", num))
                    {
                        lifecycleTransition.StorageClass = StringUnmarshaller.GetInstance().Unmarshall(context);
                    }
                }
                else if (context.get_IsEndElement() && context.get_CurrentDepth() < currentDepth)
                {
                    return(lifecycleTransition);
                }
            }
            return(lifecycleTransition);
        }
Example #8
0
        public UploadListElement Unmarshall(JsonUnmarshallerContext context)
        {
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }

            UploadListElement uploadListElement = new UploadListElement();



            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            while (context.Read())
            {
                if (context.TestExpression("MultipartUploadId", targetDepth))
                {
                    context.Read();
                    uploadListElement.MultipartUploadId = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("VaultARN", targetDepth))
                {
                    context.Read();
                    uploadListElement.VaultARN = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("ArchiveDescription", targetDepth))
                {
                    context.Read();
                    uploadListElement.ArchiveDescription = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("PartSizeInBytes", targetDepth))
                {
                    context.Read();
                    uploadListElement.PartSizeInBytes = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("CreationDate", targetDepth))
                {
                    context.Read();
                    uploadListElement.CreationDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.CurrentDepth <= originalDepth)
                {
                    return(uploadListElement);
                }
            }


            return(uploadListElement);
        }
Example #9
0
        public LifecycleRuleExpiration Unmarshall(XmlUnmarshallerContext context)
        {
            LifecycleRuleExpiration lifecycleRuleExpiration = new LifecycleRuleExpiration();
            int currentDepth = context.get_CurrentDepth();
            int num          = currentDepth + 1;

            if (context.get_IsStartOfDocument())
            {
                num += 2;
            }
            while (context.Read())
            {
                if (context.get_IsStartElement() || context.get_IsAttribute())
                {
                    if (context.TestExpression("Date", num))
                    {
                        lifecycleRuleExpiration.Date = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("Days", num))
                    {
                        lifecycleRuleExpiration.Days = IntUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("ExpiredObjectDeleteMarker", num))
                    {
                        lifecycleRuleExpiration.ExpiredObjectDeleteMarker = BoolUnmarshaller.GetInstance().Unmarshall(context);
                    }
                }
                else if (context.get_IsEndElement() && context.get_CurrentDepth() < currentDepth)
                {
                    return(lifecycleRuleExpiration);
                }
            }
            return(lifecycleRuleExpiration);
        }
        public Credentials Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            Credentials credentials  = new Credentials();
            int         currentDepth = context.CurrentDepth;

            while (context.ReadAtDepth(currentDepth))
            {
                if (context.TestExpression("AccessKeyId", currentDepth))
                {
                    StringUnmarshaller instance = StringUnmarshaller.Instance;
                    credentials.AccessKeyId = instance.Unmarshall(context);
                }
                else if (context.TestExpression("Expiration", currentDepth))
                {
                    DateTimeUnmarshaller instance2 = DateTimeUnmarshaller.Instance;
                    credentials.Expiration = instance2.Unmarshall(context);
                }
                else if (context.TestExpression("SecretKey", currentDepth))
                {
                    StringUnmarshaller instance3 = StringUnmarshaller.Instance;
                    credentials.SecretKey = instance3.Unmarshall(context);
                }
                else if (context.TestExpression("SessionToken", currentDepth))
                {
                    StringUnmarshaller instance4 = StringUnmarshaller.Instance;
                    credentials.SessionToken = instance4.Unmarshall(context);
                }
            }
            return(credentials);
        }
Example #11
0
        public StepExecutionStatusDetail Unmarshall(JsonUnmarshallerContext context)
        {
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }

            StepExecutionStatusDetail stepExecutionStatusDetail = new StepExecutionStatusDetail();



            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            while (context.Read())
            {
                if (context.TestExpression("State", targetDepth))
                {
                    context.Read();
                    stepExecutionStatusDetail.State = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("CreationDateTime", targetDepth))
                {
                    context.Read();
                    stepExecutionStatusDetail.CreationDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("StartDateTime", targetDepth))
                {
                    context.Read();
                    stepExecutionStatusDetail.StartDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("EndDateTime", targetDepth))
                {
                    context.Read();
                    stepExecutionStatusDetail.EndDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("LastStateChangeReason", targetDepth))
                {
                    context.Read();
                    stepExecutionStatusDetail.LastStateChangeReason = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.CurrentDepth <= originalDepth)
                {
                    return(stepExecutionStatusDetail);
                }
            }


            return(stepExecutionStatusDetail);
        }
Example #12
0
        public InstanceTimeline Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            InstanceTimeline instanceTimeline = new InstanceTimeline();


            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("CreationDateTime", targetDepth))
                {
                    instanceTimeline.CreationDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("ReadyDateTime", targetDepth))
                {
                    instanceTimeline.ReadyDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("EndDateTime", targetDepth))
                {
                    instanceTimeline.EndDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }
            }

            return(instanceTimeline);
        }
Example #13
0
        public S3Bucket Unmarshall(XmlUnmarshallerContext context)
        {
            S3Bucket s3Bucket     = new S3Bucket();
            int      currentDepth = context.get_CurrentDepth();
            int      num          = currentDepth + 1;

            if (context.get_IsStartOfDocument())
            {
                num += 2;
            }
            while (context.Read())
            {
                if (context.get_IsStartElement() || context.get_IsAttribute())
                {
                    if (context.TestExpression("CreationDate", num))
                    {
                        s3Bucket.CreationDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("Name", num))
                    {
                        s3Bucket.BucketName = StringUnmarshaller.GetInstance().Unmarshall(context);
                    }
                }
                else if (context.get_IsEndElement() && context.get_CurrentDepth() < currentDepth)
                {
                    return(s3Bucket);
                }
            }
            return(s3Bucket);
        }
        public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
        {
            GetConsoleOutputResponse response = new GetConsoleOutputResponse();

            int targetDepth = 2;

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("instanceId", targetDepth))
                    {
                        response.InstanceId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("timestamp", targetDepth))
                    {
                        response.Timestamp = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("output", targetDepth))
                    {
                        response.Output = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
            }


            return(response);
        }
Example #15
0
        public IdentityDescription Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            IdentityDescription identityDescription = new IdentityDescription();
            int currentDepth = context.CurrentDepth;

            while (context.ReadAtDepth(currentDepth))
            {
                if (context.TestExpression("CreationDate", currentDepth))
                {
                    DateTimeUnmarshaller instance = DateTimeUnmarshaller.Instance;
                    identityDescription.CreationDate = instance.Unmarshall(context);
                }
                else if (context.TestExpression("IdentityId", currentDepth))
                {
                    StringUnmarshaller instance2 = StringUnmarshaller.Instance;
                    identityDescription.IdentityId = instance2.Unmarshall(context);
                }
                else if (context.TestExpression("LastModifiedDate", currentDepth))
                {
                    DateTimeUnmarshaller instance3 = DateTimeUnmarshaller.Instance;
                    identityDescription.LastModifiedDate = instance3.Unmarshall(context);
                }
                else if (context.TestExpression("Logins", currentDepth))
                {
                    ListUnmarshaller <string, StringUnmarshaller> listUnmarshaller = new ListUnmarshaller <string, StringUnmarshaller>(StringUnmarshaller.Instance);
                    identityDescription.Logins = listUnmarshaller.Unmarshall(context);
                }
            }
            return(identityDescription);
        }
        public ApplicationDescription Unmarshall(UnmarshallerContext context)
        {
            ApplicationDescription applicationDescription = new ApplicationDescription();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("ApplicationName", targetDepth))
                    {
                        applicationDescription.ApplicationName = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Description", targetDepth))
                    {
                        applicationDescription.Description = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("DateCreated", targetDepth))
                    {
                        applicationDescription.DateCreated = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("DateUpdated", targetDepth))
                    {
                        applicationDescription.DateUpdated = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Versions/member", targetDepth))
                    {
                        applicationDescription.Versions.Add(StringUnmarshaller.GetInstance().Unmarshall(context));

                        continue;
                    }
                    if (context.TestExpression("ConfigurationTemplates/member", targetDepth))
                    {
                        applicationDescription.ConfigurationTemplates.Add(StringUnmarshaller.GetInstance().Unmarshall(context));

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(applicationDescription);
                }
            }

            return(applicationDescription);
        }
        public ProvisionedThroughputDescription Unmarshall(JsonUnmarshallerContext context)
        {
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }

            ProvisionedThroughputDescription provisionedThroughputDescription = new ProvisionedThroughputDescription();



            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            while (context.Read())
            {
                if (context.TestExpression("LastIncreaseDateTime", targetDepth))
                {
                    context.Read();
                    provisionedThroughputDescription.LastIncreaseDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("LastDecreaseDateTime", targetDepth))
                {
                    context.Read();
                    provisionedThroughputDescription.LastDecreaseDateTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("NumberOfDecreasesToday", targetDepth))
                {
                    context.Read();
                    provisionedThroughputDescription.NumberOfDecreasesToday = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("ReadCapacityUnits", targetDepth))
                {
                    context.Read();
                    provisionedThroughputDescription.ReadCapacityUnits = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("WriteCapacityUnits", targetDepth))
                {
                    context.Read();
                    provisionedThroughputDescription.WriteCapacityUnits = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.CurrentDepth <= originalDepth)
                {
                    return(provisionedThroughputDescription);
                }
            }


            return(provisionedThroughputDescription);
        }
        public DescribeVaultOutput Unmarshall(JsonUnmarshallerContext context)
        {
            DescribeVaultOutput describeVaultOutput = new DescribeVaultOutput();

            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            while (context.Read())
            {
                if ((context.IsKey) && (context.CurrentDepth == targetDepth))
                {
                    context.Read();
                    context.Read();

                    if (context.TestExpression("VaultARN", targetDepth))
                    {
                        describeVaultOutput.VaultARN = StringUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

                    if (context.TestExpression("VaultName", targetDepth))
                    {
                        describeVaultOutput.VaultName = StringUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

                    if (context.TestExpression("CreationDate", targetDepth))
                    {
                        describeVaultOutput.CreationDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

                    if (context.TestExpression("LastInventoryDate", targetDepth))
                    {
                        describeVaultOutput.LastInventoryDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

                    if (context.TestExpression("NumberOfArchives", targetDepth))
                    {
                        describeVaultOutput.NumberOfArchives = LongUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

                    if (context.TestExpression("SizeInBytes", targetDepth))
                    {
                        describeVaultOutput.SizeInBytes = LongUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth <= originalDepth)
                {
                    return(describeVaultOutput);
                }
            }


            return(describeVaultOutput);
        }
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            ListPartsResponse response = new ListPartsResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("MultipartUploadId", targetDepth))
                {
                    response.MultipartUploadId = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("VaultARN", targetDepth))
                {
                    response.VaultARN = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("ArchiveDescription", targetDepth))
                {
                    response.ArchiveDescription = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("PartSizeInBytes", targetDepth))
                {
                    response.PartSizeInBytes = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("CreationDate", targetDepth))
                {
                    response.CreationDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("Parts", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller <PartListElement, PartListElementUnmarshaller>(
                        PartListElementUnmarshaller.GetInstance());
                    response.Parts = unmarshaller.Unmarshall(context);

                    continue;
                }

                if (context.TestExpression("Marker", targetDepth))
                {
                    response.Marker = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }
            }

            return(response);
        }
        public ServerCertificateMetadata Unmarshall(XmlUnmarshallerContext context)
        {
            ServerCertificateMetadata serverCertificateMetadata = new ServerCertificateMetadata();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("Path", targetDepth))
                    {
                        serverCertificateMetadata.Path = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("ServerCertificateName", targetDepth))
                    {
                        serverCertificateMetadata.ServerCertificateName = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("ServerCertificateId", targetDepth))
                    {
                        serverCertificateMetadata.ServerCertificateId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Arn", targetDepth))
                    {
                        serverCertificateMetadata.Arn = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("UploadDate", targetDepth))
                    {
                        serverCertificateMetadata.UploadDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(serverCertificateMetadata);
                }
            }



            return(serverCertificateMetadata);
        }
        public SigningCertificate Unmarshall(XmlUnmarshallerContext context)
        {
            SigningCertificate signingCertificate = new SigningCertificate();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("UserName", targetDepth))
                    {
                        signingCertificate.UserName = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("CertificateId", targetDepth))
                    {
                        signingCertificate.CertificateId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("CertificateBody", targetDepth))
                    {
                        signingCertificate.CertificateBody = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Status", targetDepth))
                    {
                        signingCertificate.Status = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("UploadDate", targetDepth))
                    {
                        signingCertificate.UploadDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(signingCertificate);
                }
            }



            return(signingCertificate);
        }
Example #22
0
        public VolumeStatusEvent Unmarshall(XmlUnmarshallerContext context)
        {
            VolumeStatusEvent volumeStatusEvent = new VolumeStatusEvent();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 1;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("eventType", targetDepth))
                    {
                        volumeStatusEvent.EventType = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("description", targetDepth))
                    {
                        volumeStatusEvent.Description = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("notBefore", targetDepth))
                    {
                        volumeStatusEvent.NotBefore = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("notAfter", targetDepth))
                    {
                        volumeStatusEvent.NotAfter = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("eventId", targetDepth))
                    {
                        volumeStatusEvent.EventId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(volumeStatusEvent);
                }
            }



            return(volumeStatusEvent);
        }
        public VirtualMFADevice Unmarshall(XmlUnmarshallerContext context)
        {
            VirtualMFADevice virtualMFADevice = new VirtualMFADevice();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("SerialNumber", targetDepth))
                    {
                        virtualMFADevice.SerialNumber = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Base32StringSeed", targetDepth))
                    {
                        virtualMFADevice.Base32StringSeed = MemoryStreamUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("QRCodePNG", targetDepth))
                    {
                        virtualMFADevice.QRCodePNG = MemoryStreamUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("User", targetDepth))
                    {
                        virtualMFADevice.User = UserUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("EnableDate", targetDepth))
                    {
                        virtualMFADevice.EnableDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(virtualMFADevice);
                }
            }



            return(virtualMFADevice);
        }
        public VgwTelemetry Unmarshall(XmlUnmarshallerContext context)
        {
            VgwTelemetry vgwTelemetry  = new VgwTelemetry();
            int          originalDepth = context.CurrentDepth;
            int          targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 1;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("outsideIpAddress", targetDepth))
                    {
                        vgwTelemetry.OutsideIpAddress = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("status", targetDepth))
                    {
                        vgwTelemetry.Status = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("lastStatusChange", targetDepth))
                    {
                        vgwTelemetry.LastStatusChange = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("statusMessage", targetDepth))
                    {
                        vgwTelemetry.StatusMessage = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("acceptedRouteCount", targetDepth))
                    {
                        vgwTelemetry.AcceptedRouteCount = IntUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(vgwTelemetry);
                }
            }



            return(vgwTelemetry);
        }
        public SendDataPoint Unmarshall(XmlUnmarshallerContext context)
        {
            SendDataPoint sendDataPoint = new SendDataPoint();
            int           originalDepth = context.CurrentDepth;
            int           targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("Timestamp", targetDepth))
                    {
                        sendDataPoint.Timestamp = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("DeliveryAttempts", targetDepth))
                    {
                        sendDataPoint.DeliveryAttempts = LongUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Bounces", targetDepth))
                    {
                        sendDataPoint.Bounces = LongUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Complaints", targetDepth))
                    {
                        sendDataPoint.Complaints = LongUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Rejects", targetDepth))
                    {
                        sendDataPoint.Rejects = LongUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(sendDataPoint);
                }
            }



            return(sendDataPoint);
        }
        public AccessKey Unmarshall(XmlUnmarshallerContext context)
        {
            AccessKey accessKey     = new AccessKey();
            int       originalDepth = context.CurrentDepth;
            int       targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("UserName", targetDepth))
                    {
                        accessKey.UserName = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("AccessKeyId", targetDepth))
                    {
                        accessKey.AccessKeyId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Status", targetDepth))
                    {
                        accessKey.Status = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("SecretAccessKey", targetDepth))
                    {
                        accessKey.SecretAccessKey = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("CreateDate", targetDepth))
                    {
                        accessKey.CreateDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(accessKey);
                }
            }



            return(accessKey);
        }
Example #27
0
        public OptionStatus Unmarshall(XmlUnmarshallerContext context)
        {
            OptionStatus optionStatus  = new OptionStatus();
            int          originalDepth = context.CurrentDepth;
            int          targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("CreationDate", targetDepth))
                    {
                        optionStatus.CreationDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("UpdateDate", targetDepth))
                    {
                        optionStatus.UpdateDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("UpdateVersion", targetDepth))
                    {
                        optionStatus.UpdateVersion = IntUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("State", targetDepth))
                    {
                        optionStatus.State = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("PendingDeletion", targetDepth))
                    {
                        optionStatus.PendingDeletion = BoolUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(optionStatus);
                }
            }



            return(optionStatus);
        }
Example #28
0
        public AlarmHistoryItem Unmarshall(XmlUnmarshallerContext context)
        {
            AlarmHistoryItem alarmHistoryItem = new AlarmHistoryItem();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("AlarmName", targetDepth))
                    {
                        alarmHistoryItem.AlarmName = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Timestamp", targetDepth))
                    {
                        alarmHistoryItem.Timestamp = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("HistoryItemType", targetDepth))
                    {
                        alarmHistoryItem.HistoryItemType = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("HistorySummary", targetDepth))
                    {
                        alarmHistoryItem.HistorySummary = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("HistoryData", targetDepth))
                    {
                        alarmHistoryItem.HistoryData = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(alarmHistoryItem);
                }
            }



            return(alarmHistoryItem);
        }
        public Group Unmarshall(XmlUnmarshallerContext context)
        {
            Group group         = new Group();
            int   originalDepth = context.CurrentDepth;
            int   targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 2;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("Path", targetDepth))
                    {
                        group.Path = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("GroupName", targetDepth))
                    {
                        group.GroupName = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("GroupId", targetDepth))
                    {
                        group.GroupId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("Arn", targetDepth))
                    {
                        group.Arn = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("CreateDate", targetDepth))
                    {
                        group.CreateDate = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(group);
                }
            }



            return(group);
        }
Example #30
0
        public InstanceNetworkInterfaceAttachment Unmarshall(XmlUnmarshallerContext context)
        {
            InstanceNetworkInterfaceAttachment instanceNetworkInterfaceAttachment = new InstanceNetworkInterfaceAttachment();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

            if (context.IsStartOfDocument)
            {
                targetDepth += 1;
            }

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("attachmentId", targetDepth))
                    {
                        instanceNetworkInterfaceAttachment.AttachmentId = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("deviceIndex", targetDepth))
                    {
                        instanceNetworkInterfaceAttachment.DeviceIndex = IntUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("status", targetDepth))
                    {
                        instanceNetworkInterfaceAttachment.Status = StringUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("attachTime", targetDepth))
                    {
                        instanceNetworkInterfaceAttachment.AttachTime = DateTimeUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("deleteOnTermination", targetDepth))
                    {
                        instanceNetworkInterfaceAttachment.DeleteOnTermination = BoolUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth < originalDepth)
                {
                    return(instanceNetworkInterfaceAttachment);
                }
            }



            return(instanceNetworkInterfaceAttachment);
        }