Read() public method

Reads to the next token in the json document, and updates the context accordingly.
public Read ( ) : bool
return bool
       private static void UnmarshallResult(JsonUnmarshallerContext context,GetHostnameSuggestionResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("LayerId", targetDepth))
             {
               context.Read();
               response.LayerId = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("Hostname", targetDepth))
             {
               context.Read();
               response.Hostname = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,UpdateChapCredentialsResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("TargetARN", targetDepth))
             {
               context.Read();
               response.TargetARN = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("InitiatorName", targetDepth))
             {
               context.Read();
               response.InitiatorName = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,ResolveCaseResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("initialCaseStatus", targetDepth))
             {
               context.Read();
               response.InitialCaseStatus = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("finalCaseStatus", targetDepth))
             {
               context.Read();
               response.FinalCaseStatus = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,CreateSnapshotResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("VolumeARN", targetDepth))
             {
               context.Read();
               response.VolumeARN = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("SnapshotId", targetDepth))
             {
               context.Read();
               response.SnapshotId = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,PutRecordResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("ShardId", targetDepth))
             {
               context.Read();
               response.ShardId = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("SequenceNumber", targetDepth))
             {
               context.Read();
               response.SequenceNumber = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
        private static void UnmarshallResult(JsonUnmarshallerContext context, SimpleObjectInSDKWithoutSupportForNewSubObjectsProperty response)
        {
            int originalDepth = context.CurrentDepth;
            int targetDepth = originalDepth + 1;

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

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

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

            return;
        }
       private static void UnmarshallResult(JsonUnmarshallerContext context,CreatePresetResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("Preset", targetDepth))
             {
               context.Read();
               response.Preset = PresetUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("Warning", targetDepth))
             {
               context.Read();
               response.Warning = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,UpdateItemResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("Attributes", targetDepth))
             {
               context.Read();
               response.Attributes = new Dictionary<String,AttributeValue>();
               if (context.CurrentTokenType == JsonToken.Null)
               {
                   continue;
               }
               KeyValueUnmarshaller<string, AttributeValue, StringUnmarshaller, AttributeValueUnmarshaller> unmarshaller = new KeyValueUnmarshaller<string, AttributeValue, StringUnmarshaller, AttributeValueUnmarshaller>(StringUnmarshaller.GetInstance(), AttributeValueUnmarshaller.GetInstance());
               while (context.Read())
               {
                 JsonToken token = context.CurrentTokenType;
                 if (token == JsonToken.ArrayStart || token == JsonToken.ObjectStart)
                 {
                     continue;
                 }
                 if (token == JsonToken.ArrayEnd || token == JsonToken.ObjectEnd)
                 {
                     break;
                 }
                 KeyValuePair<string, AttributeValue> kvp = unmarshaller.Unmarshall(context);
                   response.Attributes.Add(kvp.Key, kvp.Value);
               }
               continue;
             }
 
             if (context.TestExpression("ConsumedCapacity", targetDepth))
             {
               context.Read();
               response.ConsumedCapacity = ConsumedCapacityUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("ItemCollectionMetrics", targetDepth))
             {
               context.Read();
               response.ItemCollectionMetrics = ItemCollectionMetricsUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,DescribeVTLDevicesResponse 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("VTLDevices", targetDepth))
             {
               context.Read();
               response.VTLDevices = new List<VTLDevice>();
                       VTLDeviceUnmarshaller unmarshaller = VTLDeviceUnmarshaller.GetInstance();
               while (context.Read())
               {
                 JsonToken token = context.CurrentTokenType;                
                 if (token == JsonToken.ArrayStart)
                 {
                   continue;
                 }
                 if (token == JsonToken.ArrayEnd)
                 {
                   break;
                 }
                  response.VTLDevices.Add(unmarshaller.Unmarshall(context));
               }
               continue;
             }
 
             if (context.TestExpression("Marker", targetDepth))
             {
               context.Read();
               response.Marker = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,DescribeObjectsResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("pipelineObjects", targetDepth))
             {
               context.Read();
               response.PipelineObjects = new List<PipelineObject>();
                       PipelineObjectUnmarshaller unmarshaller = PipelineObjectUnmarshaller.GetInstance();
               while (context.Read())
               {
                 JsonToken token = context.CurrentTokenType;                
                 if (token == JsonToken.ArrayStart)
                 {
                   continue;
                 }
                 if (token == JsonToken.ArrayEnd)
                 {
                   break;
                 }
                  response.PipelineObjects.Add(unmarshaller.Unmarshall(context));
               }
               continue;
             }
 
             if (context.TestExpression("marker", targetDepth))
             {
               context.Read();
               response.Marker = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("hasMoreResults", targetDepth))
             {
               context.Read();
               response.HasMoreResults = BoolUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
        private static void UnmarshallResult(JsonUnmarshallerContext context, SimpleObjectInSDKWithSupportForNewSubObjectsProperty response)
        {
            int originalDepth = context.CurrentDepth;
            int targetDepth = originalDepth + 1;

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

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

                if (context.TestExpression("SubObjects1", targetDepth))
                {
                    context.Read();
                    response.SubObjects1 = new List<SimpleObjectInSDKWithSupportForNewSubObjectsProperty.SubObject>();

                    SimpleSubObjectUnmarshaller unmarshaller = new SimpleSubObjectUnmarshaller();
                    while (context.Read())
                    {
                        JsonToken token = context.CurrentTokenType;
                        if (token == JsonToken.ArrayStart)
                        {
                            continue;
                        }
                        if (token == JsonToken.ArrayEnd)
                        {
                            break;
                        }
                        response.SubObjects1.Add(unmarshaller.Unmarshall(context));
                    }
                    continue;
                }

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

            return;
        }
       private static void UnmarshallResult(JsonUnmarshallerContext context,ListClustersResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("Clusters", targetDepth))
             {
               context.Read();
               
               if (context.CurrentTokenType == JsonToken.Null)
               {
                   response.Clusters = null;
                   continue;
               }
                 response.Clusters = new List<ClusterSummary>();
                 ClusterSummaryUnmarshaller unmarshaller = ClusterSummaryUnmarshaller.GetInstance();
               while (context.Read())
               {
                 JsonToken token = context.CurrentTokenType;                
                 if (token == JsonToken.ArrayStart)
                 {
                   continue;
                 }
                 if (token == JsonToken.ArrayEnd)
                 {
                   break;
                 }
                  response.Clusters.Add(unmarshaller.Unmarshall(context));
               }
               continue;
             }
 
             if (context.TestExpression("Marker", targetDepth))
             {
               context.Read();
               response.Marker = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,DescribeCasesResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("cases", targetDepth))
             {
               context.Read();
               
               if (context.CurrentTokenType == JsonToken.Null)
               {
                   response.Cases = null;
                   continue;
               }
                 response.Cases = new List<CaseDetails>();
                 CaseDetailsUnmarshaller unmarshaller = CaseDetailsUnmarshaller.GetInstance();
               while (context.Read())
               {
                 JsonToken token = context.CurrentTokenType;                
                 if (token == JsonToken.ArrayStart)
                 {
                   continue;
                 }
                 if (token == JsonToken.ArrayEnd)
                 {
                   break;
                 }
                  response.Cases.Add(unmarshaller.Unmarshall(context));
               }
               continue;
             }
 
             if (context.TestExpression("nextToken", targetDepth))
             {
               context.Read();
               response.NextToken = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,AddInstanceGroupsResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("JobFlowId", targetDepth))
             {
               context.Read();
               response.JobFlowId = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("InstanceGroupIds", targetDepth))
             {
               context.Read();
               
               if (context.CurrentTokenType == JsonToken.Null)
               {
                   response.InstanceGroupIds = null;
                   continue;
               }
                 response.InstanceGroupIds = 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.InstanceGroupIds.Add(unmarshaller.Unmarshall(context));
               }
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,ListPresetsResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("Presets", targetDepth))
             {
               context.Read();
               
               if (context.CurrentTokenType == JsonToken.Null)
               {
                   response.Presets = null;
                   continue;
               }
                 response.Presets = new List<Preset>();
                 PresetUnmarshaller unmarshaller = PresetUnmarshaller.GetInstance();
               while (context.Read())
               {
                 JsonToken token = context.CurrentTokenType;                
                 if (token == JsonToken.ArrayStart)
                 {
                   continue;
                 }
                 if (token == JsonToken.ArrayEnd)
                 {
                   break;
                 }
                  response.Presets.Add(unmarshaller.Unmarshall(context));
               }
               continue;
             }
 
             if (context.TestExpression("NextPageToken", targetDepth))
             {
               context.Read();
               response.NextPageToken = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,ListVaultsResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("VaultList", targetDepth))
             {
               context.Read();
               
               if (context.CurrentTokenType == JsonToken.Null)
               {
                   response.VaultList = null;
                   continue;
               }
                 response.VaultList = new List<DescribeVaultOutput>();
                 DescribeVaultOutputUnmarshaller unmarshaller = DescribeVaultOutputUnmarshaller.GetInstance();
               while (context.Read())
               {
                 JsonToken token = context.CurrentTokenType;                
                 if (token == JsonToken.ArrayStart)
                 {
                   continue;
                 }
                 if (token == JsonToken.ArrayEnd)
                 {
                   break;
                 }
                  response.VaultList.Add(unmarshaller.Unmarshall(context));
               }
               continue;
             }
 
             if (context.TestExpression("Marker", targetDepth))
             {
               context.Read();
               response.Marker = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
       private static void UnmarshallResult(JsonUnmarshallerContext context,ListTablesResponse response)
       {
         
           int originalDepth = context.CurrentDepth;
           int targetDepth = originalDepth + 1;
           while (context.Read())
           {
             
             if (context.TestExpression("TableNames", targetDepth))
             {
               context.Read();
               response.TableNames = new List<String>();
               if (context.CurrentTokenType == JsonToken.Null)
               {
                   continue;
               }
                 StringUnmarshaller unmarshaller = StringUnmarshaller.GetInstance();
               while (context.Read())
               {
                 JsonToken token = context.CurrentTokenType;                
                 if (token == JsonToken.ArrayStart)
                 {
                   continue;
                 }
                 if (token == JsonToken.ArrayEnd)
                 {
                   break;
                 }
                  response.TableNames.Add(unmarshaller.Unmarshall(context));
               }
               continue;
             }
 
             if (context.TestExpression("LastEvaluatedTableName", targetDepth))
             {
               context.Read();
               response.LastEvaluatedTableName = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
               if (context.CurrentDepth <= originalDepth)
               {                   
                   return;
               }
           }
                       
           return;
       }                        
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            ListIdentitiesResponse response = new ListIdentitiesResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("Identities", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<IdentityDescription, IdentityDescriptionUnmarshaller>(IdentityDescriptionUnmarshaller.Instance);
                    response.Identities = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("IdentityPoolId", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.IdentityPoolId = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("NextToken", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.NextToken = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return response;
        }
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            GenerateDataKeyResponse response = new GenerateDataKeyResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("CiphertextBlob", targetDepth))
                {
                    var unmarshaller = MemoryStreamUnmarshaller.Instance;
                    response.CiphertextBlob = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("KeyId", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.KeyId = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("Plaintext", targetDepth))
                {
                    var unmarshaller = MemoryStreamUnmarshaller.Instance;
                    response.Plaintext = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return response;
        }
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            DescribeMountTargetsResponse response = new DescribeMountTargetsResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("Marker", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.Marker = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("MountTargets", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<MountTargetDescription, MountTargetDescriptionUnmarshaller>(MountTargetDescriptionUnmarshaller.Instance);
                    response.MountTargets = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("NextMarker", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.NextMarker = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

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

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("Instances", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<Instance, InstanceUnmarshaller>(InstanceUnmarshaller.Instance);
                    response.Instances = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("Marker", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.Marker = unmarshaller.Unmarshall(context);
                    continue;
                }
            }
 

            return response;
        }
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            GetRecordsResponse response = new GetRecordsResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("MillisBehindLatest", targetDepth))
                {
                    var unmarshaller = LongUnmarshaller.Instance;
                    response.MillisBehindLatest = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("NextShardIterator", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.NextShardIterator = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("Records", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<Record, RecordUnmarshaller>(RecordUnmarshaller.Instance);
                    response.Records = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return response;
        }
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            UpdateMethodResponseResponse response = new UpdateMethodResponseResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("responseModels", targetDepth))
                {
                    var unmarshaller = new DictionaryUnmarshaller<string, string, StringUnmarshaller, StringUnmarshaller>(StringUnmarshaller.Instance, StringUnmarshaller.Instance);
                    response.ResponseModels = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("responseParameters", targetDepth))
                {
                    var unmarshaller = new DictionaryUnmarshaller<string, bool, StringUnmarshaller, BoolUnmarshaller>(StringUnmarshaller.Instance, BoolUnmarshaller.Instance);
                    response.ResponseParameters = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("statusCode", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.StatusCode = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return response;
        }
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            GetIdentityPoolConfigurationResponse response = new GetIdentityPoolConfigurationResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("CognitoStreams", targetDepth))
                {
                    var unmarshaller = CognitoStreamsUnmarshaller.Instance;
                    response.CognitoStreams = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("IdentityPoolId", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.IdentityPoolId = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("PushSync", targetDepth))
                {
                    var unmarshaller = PushSyncUnmarshaller.Instance;
                    response.PushSync = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

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

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("events", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<OutputLogEvent, OutputLogEventUnmarshaller>(OutputLogEventUnmarshaller.Instance);
                    response.Events = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("nextBackwardToken", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.NextBackwardToken = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("nextForwardToken", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.NextForwardToken = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return response;
        }
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            CreateEventSourceMappingResponse response = new CreateEventSourceMappingResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("BatchSize", targetDepth))
                {
                    var unmarshaller = IntUnmarshaller.Instance;
                    response.BatchSize = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("EventSourceArn", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.EventSourceArn = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("FunctionArn", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.FunctionArn = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("LastModified", targetDepth))
                {
                    var unmarshaller = DateTimeUnmarshaller.Instance;
                    response.LastModified = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("LastProcessingResult", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.LastProcessingResult = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("State", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.State = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("StateTransitionReason", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.StateTransitionReason = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("UUID", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.UUID = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return response;
        }
       public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
       {
           TestRoleResponse response = new TestRoleResponse();       
         
           context.Read();
           int targetDepth = context.CurrentDepth;
           while (context.ReadAtDepth(targetDepth))
           {
             
             if (context.TestExpression("Success", targetDepth))
             {
               response.Success = StringUnmarshaller.GetInstance().Unmarshall(context);
               continue;
             }
 
             if (context.TestExpression("Messages", targetDepth))
             {
               
               var unmarshaller = new ListUnmarshaller<String,StringUnmarshaller>(
                   StringUnmarshaller.GetInstance());                  
               response.Messages = unmarshaller.Unmarshall(context);
               
               continue;
             }
 
           }
                       
           return response;
       }                        
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            DescribeRecordResponse response = new DescribeRecordResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("NextPageToken", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.NextPageToken = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("RecordDetail", targetDepth))
                {
                    var unmarshaller = RecordDetailUnmarshaller.Instance;
                    response.RecordDetail = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("RecordOutputs", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<RecordOutput, RecordOutputUnmarshaller>(RecordOutputUnmarshaller.Instance);
                    response.RecordOutputs = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return response;
        }
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            BatchWriteItemResponse response = new BatchWriteItemResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("ConsumedCapacity", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<ConsumedCapacity, ConsumedCapacityUnmarshaller>(ConsumedCapacityUnmarshaller.Instance);
                    response.ConsumedCapacity = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("ItemCollectionMetrics", targetDepth))
                {
                    var unmarshaller = new DictionaryUnmarshaller<string, List<ItemCollectionMetrics>, StringUnmarshaller, ListUnmarshaller<ItemCollectionMetrics, ItemCollectionMetricsUnmarshaller>>(StringUnmarshaller.Instance, new ListUnmarshaller<ItemCollectionMetrics, ItemCollectionMetricsUnmarshaller>(ItemCollectionMetricsUnmarshaller.Instance));
                    response.ItemCollectionMetrics = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("UnprocessedItems", targetDepth))
                {
                    var unmarshaller = new DictionaryUnmarshaller<string, List<WriteRequest>, StringUnmarshaller, ListUnmarshaller<WriteRequest, WriteRequestUnmarshaller>>(StringUnmarshaller.Instance, new ListUnmarshaller<WriteRequest, WriteRequestUnmarshaller>(WriteRequestUnmarshaller.Instance));
                    response.UnprocessedItems = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return response;
        }
        /// <summary>
        /// Unmarshaller the response from the service to the response class.
        /// </summary>  
        /// <param name="context"></param>
        /// <returns></returns>
        public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
        {
            SearchProductsResponse response = new SearchProductsResponse();

            context.Read();
            int targetDepth = context.CurrentDepth;
            while (context.ReadAtDepth(targetDepth))
            {
                if (context.TestExpression("NextPageToken", targetDepth))
                {
                    var unmarshaller = StringUnmarshaller.Instance;
                    response.NextPageToken = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("ProductViewAggregations", targetDepth))
                {
                    var unmarshaller = new DictionaryUnmarshaller<string, List<ProductViewAggregationValue>, StringUnmarshaller, ListUnmarshaller<ProductViewAggregationValue, ProductViewAggregationValueUnmarshaller>>(StringUnmarshaller.Instance, new ListUnmarshaller<ProductViewAggregationValue, ProductViewAggregationValueUnmarshaller>(ProductViewAggregationValueUnmarshaller.Instance));
                    response.ProductViewAggregations = unmarshaller.Unmarshall(context);
                    continue;
                }
                if (context.TestExpression("ProductViewSummaries", targetDepth))
                {
                    var unmarshaller = new ListUnmarshaller<ProductViewSummary, ProductViewSummaryUnmarshaller>(ProductViewSummaryUnmarshaller.Instance);
                    response.ProductViewSummaries = unmarshaller.Unmarshall(context);
                    continue;
                }
            }

            return response;
        }