public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            DescribeBandwidthRateLimitResponse response = new DescribeBandwidthRateLimitResponse();

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

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

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

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

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

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

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

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

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

            return(response);
        }
コード例 #3
0
        public TimerFiredEventAttributes Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            TimerFiredEventAttributes timerFiredEventAttributes = new TimerFiredEventAttributes();


            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("timerId", targetDepth))
                {
                    timerFiredEventAttributes.TimerId = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("startedEventId", targetDepth))
                {
                    timerFiredEventAttributes.StartedEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }
            }

            return(timerFiredEventAttributes);
        }
コード例 #4
0
        public ChildWorkflowExecutionTimedOutEventAttributes Unmarshall(JsonUnmarshallerContext context)
        {
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }

            ChildWorkflowExecutionTimedOutEventAttributes childWorkflowExecutionTimedOutEventAttributes = new ChildWorkflowExecutionTimedOutEventAttributes();



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

            while (context.Read())
            {
                if (context.TestExpression("workflowExecution", targetDepth))
                {
                    context.Read();
                    childWorkflowExecutionTimedOutEventAttributes.WorkflowExecution = WorkflowExecutionUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("workflowType", targetDepth))
                {
                    context.Read();
                    childWorkflowExecutionTimedOutEventAttributes.WorkflowType = WorkflowTypeUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("timeoutType", targetDepth))
                {
                    context.Read();
                    childWorkflowExecutionTimedOutEventAttributes.TimeoutType = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("initiatedEventId", targetDepth))
                {
                    context.Read();
                    childWorkflowExecutionTimedOutEventAttributes.InitiatedEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("startedEventId", targetDepth))
                {
                    context.Read();
                    childWorkflowExecutionTimedOutEventAttributes.StartedEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

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


            return(childWorkflowExecutionTimedOutEventAttributes);
        }
        public ActivityTaskCompletedEventAttributes Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            ActivityTaskCompletedEventAttributes activityTaskCompletedEventAttributes = new ActivityTaskCompletedEventAttributes();


            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("result", targetDepth))
                {
                    activityTaskCompletedEventAttributes.Result = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("scheduledEventId", targetDepth))
                {
                    activityTaskCompletedEventAttributes.ScheduledEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("startedEventId", targetDepth))
                {
                    activityTaskCompletedEventAttributes.StartedEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }
            }

            return(activityTaskCompletedEventAttributes);
        }
        public MarkerRecordedEventAttributes Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            MarkerRecordedEventAttributes markerRecordedEventAttributes = new MarkerRecordedEventAttributes();


            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("markerName", targetDepth))
                {
                    markerRecordedEventAttributes.MarkerName = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("details", targetDepth))
                {
                    markerRecordedEventAttributes.Details = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("decisionTaskCompletedEventId", targetDepth))
                {
                    markerRecordedEventAttributes.DecisionTaskCompletedEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }
            }

            return(markerRecordedEventAttributes);
        }
        public DecisionTaskCompletedEventAttributes Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            DecisionTaskCompletedEventAttributes decisionTaskCompletedEventAttributes = new DecisionTaskCompletedEventAttributes();


            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("executionContext", targetDepth))
                {
                    decisionTaskCompletedEventAttributes.ExecutionContext = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("scheduledEventId", targetDepth))
                {
                    decisionTaskCompletedEventAttributes.ScheduledEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("startedEventId", targetDepth))
                {
                    decisionTaskCompletedEventAttributes.StartedEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }
            }

            return(decisionTaskCompletedEventAttributes);
        }
        public CancelTimerFailedEventAttributes Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            CancelTimerFailedEventAttributes cancelTimerFailedEventAttributes = new CancelTimerFailedEventAttributes();


            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("timerId", targetDepth))
                {
                    cancelTimerFailedEventAttributes.TimerId = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("cause", targetDepth))
                {
                    cancelTimerFailedEventAttributes.Cause = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("decisionTaskCompletedEventId", targetDepth))
                {
                    cancelTimerFailedEventAttributes.DecisionTaskCompletedEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }
            }

            return(cancelTimerFailedEventAttributes);
        }
コード例 #9
0
        public TimerFiredEventAttributes Unmarshall(JsonUnmarshallerContext context)
        {
            TimerFiredEventAttributes timerFiredEventAttributes = new TimerFiredEventAttributes();

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

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

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

                    if (context.TestExpression("StartedEventId", targetDepth))
                    {
                        timerFiredEventAttributes.StartedEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth <= originalDepth)
                {
                    return(timerFiredEventAttributes);
                }
            }
            return(timerFiredEventAttributes);
        }
コード例 #10
0
        public TrustedAdvisorCheckRefreshStatus Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            TrustedAdvisorCheckRefreshStatus trustedAdvisorCheckRefreshStatus = new TrustedAdvisorCheckRefreshStatus();


            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("checkId", targetDepth))
                {
                    trustedAdvisorCheckRefreshStatus.CheckId = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

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

                if (context.TestExpression("millisUntilNextRefreshable", targetDepth))
                {
                    trustedAdvisorCheckRefreshStatus.MillisUntilNextRefreshable = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }
            }

            return(trustedAdvisorCheckRefreshStatus);
        }
        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 ActivityTaskStartedEventAttributes Unmarshall(JsonUnmarshallerContext context)
        {
            ActivityTaskStartedEventAttributes activityTaskStartedEventAttributes = new ActivityTaskStartedEventAttributes();

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

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

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

                    if (context.TestExpression("ScheduledEventId", targetDepth))
                    {
                        activityTaskStartedEventAttributes.ScheduledEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth <= originalDepth)
                {
                    return(activityTaskStartedEventAttributes);
                }
            }
            return(activityTaskStartedEventAttributes);
        }
コード例 #13
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);
        }
コード例 #14
0
        public Disk Unmarshall(JsonUnmarshallerContext context)
        {
            Disk disk = new Disk();

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

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

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

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

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

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

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

                    if (context.TestExpression("DiskAllocationResource", targetDepth))
                    {
                        disk.DiskAllocationResource = StringUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth <= originalDepth)
                {
                    return(disk);
                }
            }


            return(disk);
        }
        public ChildWorkflowExecutionFailedEventAttributes Unmarshall(JsonUnmarshallerContext context)
        {
            ChildWorkflowExecutionFailedEventAttributes childWorkflowExecutionFailedEventAttributes = new ChildWorkflowExecutionFailedEventAttributes();

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

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

                    if (context.TestExpression("WorkflowExecution", targetDepth))
                    {
                        childWorkflowExecutionFailedEventAttributes.WorkflowExecution = WorkflowExecutionUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

                    if (context.TestExpression("WorkflowType", targetDepth))
                    {
                        childWorkflowExecutionFailedEventAttributes.WorkflowType = WorkflowTypeUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

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

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

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

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


            return(childWorkflowExecutionFailedEventAttributes);
        }
コード例 #16
0
        public DescribeVaultResult Unmarshall(JsonUnmarshallerContext context)
        {
            DescribeVaultResult describeVaultResult = new DescribeVaultResult();

            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))
                    {
                        describeVaultResult.VaultARN = StringUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

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

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

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

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

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


            return(describeVaultResult);
        }
        public DescribeWorkingStorageResult Unmarshall(JsonUnmarshallerContext context)
        {
            DescribeWorkingStorageResult describeWorkingStorageResult = new DescribeWorkingStorageResult();

            describeWorkingStorageResult.DiskIds = null;

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

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

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

                    if (context.TestExpression("DiskIds", targetDepth))
                    {
                        describeWorkingStorageResult.DiskIds = new List <String>();
                        StringUnmarshaller unmarshaller = StringUnmarshaller.GetInstance();
                        while (context.Read())
                        {
                            if ((context.IsArrayElement) && (context.CurrentDepth == targetDepth))
                            {
                                describeWorkingStorageResult.DiskIds.Add(unmarshaller.Unmarshall(context));
                            }
                            else if (context.IsEndArray)
                            {
                                break;
                            }
                        }
                        continue;
                    }

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

                    if (context.TestExpression("WorkingStorageAllocatedInBytes", targetDepth))
                    {
                        describeWorkingStorageResult.WorkingStorageAllocatedInBytes = LongUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth <= originalDepth)
                {
                    return(describeWorkingStorageResult);
                }
            }
            return(describeWorkingStorageResult);
        }
コード例 #18
0
        public ActivityTask Unmarshall(JsonUnmarshallerContext context)
        {
            ActivityTask activityTask = new ActivityTask();

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

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

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

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

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

                    if (context.TestExpression("WorkflowExecution", targetDepth))
                    {
                        activityTask.WorkflowExecution = WorkflowExecutionUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

                    if (context.TestExpression("ActivityType", targetDepth))
                    {
                        activityTask.ActivityType = ActivityTypeUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }

                    if (context.TestExpression("Input", targetDepth))
                    {
                        activityTask.Input = StringUnmarshaller.GetInstance().Unmarshall(context);
                        continue;
                    }
                }
                else if (context.IsEndElement && context.CurrentDepth <= originalDepth)
                {
                    return(activityTask);
                }
            }


            return(activityTask);
        }
コード例 #19
0
        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);
        }
コード例 #20
0
        private static void UnmarshallResult(JsonUnmarshallerContext context, DescribeWorkingStorageResponse response)
        {
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

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

                if (context.TestExpression("DiskIds", targetDepth))
                {
                    context.Read();
                    response.DiskIds = new List <String>();
                    StringUnmarshaller unmarshaller = StringUnmarshaller.GetInstance();
                    while (context.Read())
                    {
                        JsonToken token = context.CurrentTokenType;
                        if (token == JsonToken.ArrayStart)
                        {
                            continue;
                        }
                        if (token == JsonToken.ArrayEnd)
                        {
                            break;
                        }
                        response.DiskIds.Add(unmarshaller.Unmarshall(context));
                    }
                    continue;
                }

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

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

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

            return;
        }
コード例 #21
0
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            DescribeCacheResponse response = new DescribeCacheResponse();

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

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

                if (context.TestExpression("DiskIds", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller <String, StringUnmarshaller>(
                        StringUnmarshaller.GetInstance());
                    response.DiskIds = unmarshaller.Unmarshall(context);

                    continue;
                }

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

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

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

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

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

            return(response);
        }
コード例 #22
0
        private static void UnmarshallResult(JsonUnmarshallerContext context, DescribeVaultResponse response)
        {
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

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

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

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

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

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

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

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

            return;
        }
コード例 #23
0
        public IntArrayOptions Unmarshall(XmlUnmarshallerContext context)
        {
            IntArrayOptions intArrayOptions = new IntArrayOptions();
            int             originalDepth   = context.CurrentDepth;
            int             targetDepth     = originalDepth + 1;

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

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("DefaultValue", targetDepth))
                    {
                        intArrayOptions.DefaultValue = LongUnmarshaller.GetInstance().Unmarshall(context);

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

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

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

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

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



            return(intArrayOptions);
        }
コード例 #24
0
        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);
        }
コード例 #25
0
        public DefaultCacheBehavior Unmarshall(XmlUnmarshallerContext context)
        {
            DefaultCacheBehavior defaultCacheBehavior = new DefaultCacheBehavior();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

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

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

                        continue;
                    }
                    if (context.TestExpression("ForwardedValues", targetDepth))
                    {
                        defaultCacheBehavior.ForwardedValues = ForwardedValuesUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("TrustedSigners", targetDepth))
                    {
                        defaultCacheBehavior.TrustedSigners = TrustedSignersUnmarshaller.GetInstance().Unmarshall(context);

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

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

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



            return(defaultCacheBehavior);
        }
コード例 #26
0
        public HostedZone Unmarshall(XmlUnmarshallerContext context)
        {
            HostedZone hostedZone    = new HostedZone();
            int        originalDepth = context.CurrentDepth;
            int        targetDepth   = originalDepth + 1;

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

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

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

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

                        continue;
                    }
                    if (context.TestExpression("Config", targetDepth))
                    {
                        hostedZone.Config = HostedZoneConfigUnmarshaller.GetInstance().Unmarshall(context);

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

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



            return(hostedZone);
        }
コード例 #27
0
        public ImportVolumeTaskDetails Unmarshall(XmlUnmarshallerContext context)
        {
            ImportVolumeTaskDetails importVolumeTaskDetails = new ImportVolumeTaskDetails();
            int originalDepth = context.CurrentDepth;
            int targetDepth   = originalDepth + 1;

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

            while (context.Read())
            {
                if (context.IsStartElement || context.IsAttribute)
                {
                    if (context.TestExpression("bytesConverted", targetDepth))
                    {
                        importVolumeTaskDetails.BytesConverted = LongUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("availabilityZone", targetDepth))
                    {
                        importVolumeTaskDetails.AvailabilityZone = StringUnmarshaller.GetInstance().Unmarshall(context);

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

                        continue;
                    }
                    if (context.TestExpression("image", targetDepth))
                    {
                        importVolumeTaskDetails.Image = DiskImageDescriptionUnmarshaller.GetInstance().Unmarshall(context);

                        continue;
                    }
                    if (context.TestExpression("volume", targetDepth))
                    {
                        importVolumeTaskDetails.Volume = DiskImageVolumeDescriptionUnmarshaller.GetInstance().Unmarshall(context);

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



            return(importVolumeTaskDetails);
        }
コード例 #28
0
        public S3ObjectVersion Unmarshall(XmlUnmarshallerContext context)
        {
            S3ObjectVersion s3ObjectVersion = new S3ObjectVersion();
            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("ETag", num))
                    {
                        s3ObjectVersion.ETag = StringUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("IsLatest", num))
                    {
                        s3ObjectVersion.IsLatest = BoolUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("Key", num))
                    {
                        s3ObjectVersion.Key = StringUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("LastModified", num))
                    {
                        s3ObjectVersion.LastModified = DateTimeUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("Owner", num))
                    {
                        s3ObjectVersion.Owner = OwnerUnmarshaller.Instance.Unmarshall(context);
                    }
                    else if (context.TestExpression("Size", num))
                    {
                        s3ObjectVersion.Size = LongUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("StorageClass", num))
                    {
                        s3ObjectVersion.StorageClass = StringUnmarshaller.GetInstance().Unmarshall(context);
                    }
                    else if (context.TestExpression("VersionId", num))
                    {
                        s3ObjectVersion.VersionId = StringUnmarshaller.GetInstance().Unmarshall(context);
                    }
                }
                else if (context.get_IsEndElement() && context.get_CurrentDepth() < currentDepth)
                {
                    return(s3ObjectVersion);
                }
            }
            return(s3ObjectVersion);
        }
コード例 #29
0
        public Disk Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            Disk disk = new Disk();


            int targetDepth = context.CurrentDepth;

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

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

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

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

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

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

            return(disk);
        }
コード例 #30
0
        public ActivityTask Unmarshall(JsonUnmarshallerContext context)
        {
            context.Read();
            if (context.CurrentTokenType == JsonToken.Null)
            {
                return(null);
            }
            ActivityTask activityTask = new ActivityTask();


            int targetDepth = context.CurrentDepth;

            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("taskToken", targetDepth))
                {
                    activityTask.TaskToken = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("activityId", targetDepth))
                {
                    activityTask.ActivityId = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("startedEventId", targetDepth))
                {
                    activityTask.StartedEventId = LongUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

                if (context.TestExpression("workflowExecution", targetDepth))
                {
                    activityTask.WorkflowExecution = WorkflowExecutionUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }

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

                if (context.TestExpression("input", targetDepth))
                {
                    activityTask.Input = StringUnmarshaller.GetInstance().Unmarshall(context);
                    continue;
                }
            }

            return(activityTask);
        }