internal BatchPutAttributesResponse BatchPutAttributes(BatchPutAttributesRequest request)
{
var marshaller = new BatchPutAttributesRequestMarshaller();
var unmarshaller = BatchPutAttributesResponseUnmarshaller.Instance;
return(Invoke <BatchPutAttributesRequest, BatchPutAttributesResponse>(request, marshaller, unmarshaller));
}
/// <summary>
/// Initiates the asynchronous execution of the BatchPutAttributes operation.
/// <seealso cref="Amazon.SimpleDB.IAmazonSimpleDB.BatchPutAttributes"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <BatchPutAttributesResponse> BatchPutAttributesAsync(BatchPutAttributesRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new BatchPutAttributesRequestMarshaller();
var unmarshaller = BatchPutAttributesResponseUnmarshaller.GetInstance();
return(Invoke <IRequest, BatchPutAttributesRequest, BatchPutAttributesResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
/// <summary>
/// Initiates the asynchronous execution of the BatchPutAttributes operation.
/// <seealso cref="Amazon.SimpleDB.IAmazonSimpleDB"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <BatchPutAttributesResponse> BatchPutAttributesAsync(BatchPutAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new BatchPutAttributesRequestMarshaller();
var unmarshaller = BatchPutAttributesResponseUnmarshaller.Instance;
return(InvokeAsync <BatchPutAttributesRequest, BatchPutAttributesResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public void BatchPutAttributesMarshallTest()
{
var operation = service_model.FindOperation("BatchPutAttributes");
var request = InstantiateClassGenerator.Execute <BatchPutAttributesRequest>();
var marshaller = new BatchPutAttributesRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
var validator = new AWSQueryValidator(internalRequest.Parameters, request, service_model, operation);
validator.Validate();
}
public void BatchPutAttributesMarshallTest()
{
var operation = service_model.FindOperation("BatchPutAttributes");
var request = InstantiateClassGenerator.Execute<BatchPutAttributesRequest>();
var marshaller = new BatchPutAttributesRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
var validator = new AWSQueryValidator(internalRequest.Parameters, request, service_model, operation);
validator.Validate();
}
/// <summary>
/// <para> The <c>BatchPutAttributes</c> operation creates or replaces attributes within one or more items. By using this operation, the client
/// can perform multiple PutAttribute operation with a single call. This helps yield savings in round trips and latencies, enabling Amazon
/// SimpleDB to optimize requests and generally produce better throughput. </para> <para> The client may specify the item name with the
/// <c>Item.X.ItemName</c> parameter. The client may specify new attributes using a combination of the <c>Item.X.Attribute.Y.Name</c> and
/// <c>Item.X.Attribute.Y.Value</c> parameters. The client may specify the first attribute for the first item using the parameters
/// <c>Item.0.Attribute.0.Name</c> and <c>Item.0.Attribute.0.Value</c> ,
/// and for the second attribute for the first item by the parameters <c>Item.0.Attribute.1.Name</c> and <c>Item.0.Attribute.1.Value</c> ,
/// and so on. </para> <para> Attributes are uniquely identified within an item by their name/value combination. For example, a single item
/// can have the attributes <c>{ "first_name", "first_value" }</c> and <c>{ "first_name", "second_value" }</c> .
/// However, it cannot have two attribute instances where both the <c>Item.X.Attribute.Y.Name</c> and <c>Item.X.Attribute.Y.Value</c> are the
/// same. </para> <para> Optionally, the requester can supply the <c>Replace</c> parameter for each individual value. Setting this value to
/// <c>true</c> will cause the new attribute values to replace the existing attribute values. For example, if an item <c>I</c> has the
/// attributes <c>{ 'a', '1' }, { 'b', '2'}</c> and <c>{ 'b', '3' }</c> and the requester does a BatchPutAttributes of <c>{'I', 'b', '4' }</c>
/// with the Replace parameter set to true, the final attributes of the item will be <c>{ 'a', '1' }</c> and <c>{ 'b', '4' }</c> ,
/// replacing the previous values of the 'b' attribute with the new value. </para> <para><b>NOTE:</b> You cannot specify an empty string as an
/// item or as an attribute name. The BatchPutAttributes operation succeeds or fails in its entirety. There are no partial puts. </para>
/// <para><b>IMPORTANT:</b> This operation is vulnerable to exceeding the maximum URL size when making a REST request using the HTTP GET method.
/// This operation does not support conditions using Expected.X.Name, Expected.X.Value, or Expected.X.Exists. </para> <para> You can execute
/// multiple <c>BatchPutAttributes</c> operations and other operations in parallel. However, large numbers of concurrent
/// <c>BatchPutAttributes</c> calls can result in Service Unavailable (503) responses. </para> <para> The following limitations are enforced for
/// this operation:
/// <ul>
/// <li>256 attribute name-value pairs per item</li>
/// <li>1 MB request size</li>
/// <li>1 billion attributes per domain</li>
/// <li>10 GB of total user data storage per domain</li>
/// <li>25 item limit per <c>BatchPutAttributes</c> operation</li>
///
/// </ul>
/// </para>
/// </summary>
///
/// <param name="batchPutAttributesRequest">Container for the necessary parameters to execute the BatchPutAttributes service method on
/// AmazonSimpleDB.</param>
///
/// <exception cref="T:Amazon.SimpleDB.Model.DuplicateItemNameException" />
/// <exception cref="T:Amazon.SimpleDB.Model.InvalidParameterValueException" />
/// <exception cref="T:Amazon.SimpleDB.Model.NumberDomainBytesExceededException" />
/// <exception cref="T:Amazon.SimpleDB.Model.NumberSubmittedItemsExceededException" />
/// <exception cref="T:Amazon.SimpleDB.Model.NumberSubmittedAttributesExceededException" />
/// <exception cref="T:Amazon.SimpleDB.Model.NumberDomainAttributesExceededException" />
/// <exception cref="T:Amazon.SimpleDB.Model.NoSuchDomainException" />
/// <exception cref="T:Amazon.SimpleDB.Model.NumberItemAttributesExceededException" />
/// <exception cref="T:Amazon.SimpleDB.Model.MissingParameterException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public async Task<BatchPutAttributesResponse> BatchPutAttributesAsync(BatchPutAttributesRequest batchPutAttributesRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new BatchPutAttributesRequestMarshaller();
var unmarshaller = BatchPutAttributesResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, BatchPutAttributesRequest, BatchPutAttributesResponse>(batchPutAttributesRequest, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
/// <summary>
/// Initiates the asynchronous execution of the BatchPutAttributes operation.
/// <seealso cref="Amazon.SimpleDB.IAmazonSimpleDB"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<BatchPutAttributesResponse> BatchPutAttributesAsync(BatchPutAttributesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new BatchPutAttributesRequestMarshaller();
var unmarshaller = BatchPutAttributesResponseUnmarshaller.Instance;
return InvokeAsync<BatchPutAttributesRequest,BatchPutAttributesResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// The <code>BatchPutAttributes</code> operation creates or replaces attributes within
/// one or more items. By using this operation, the client can perform multiple <a>PutAttribute</a>
/// operation with a single call. This helps yield savings in round trips and latencies,
/// enabling Amazon SimpleDB to optimize requests and generally produce better throughput.
///
///
///
/// <para>
/// The client may specify the item name with the <code>Item.X.ItemName</code> parameter.
/// The client may specify new attributes using a combination of the <code>Item.X.Attribute.Y.Name</code>
/// and <code>Item.X.Attribute.Y.Value</code> parameters. The client may specify the first
/// attribute for the first item using the parameters <code>Item.0.Attribute.0.Name</code>
/// and <code>Item.0.Attribute.0.Value</code>, and for the second attribute for the first
/// item by the parameters <code>Item.0.Attribute.1.Name</code> and <code>Item.0.Attribute.1.Value</code>,
/// and so on.
/// </para>
///
/// <para>
/// Attributes are uniquely identified within an item by their name/value combination.
/// For example, a single item can have the attributes <code>{ "first_name", "first_value"
/// }</code> and <code>{ "first_name", "second_value" }</code>. However, it cannot have
/// two attribute instances where both the <code>Item.X.Attribute.Y.Name</code> and <code>Item.X.Attribute.Y.Value</code>
/// are the same.
/// </para>
///
/// <para>
/// Optionally, the requester can supply the <code>Replace</code> parameter for each
/// individual value. Setting this value to <code>true</code> will cause the new attribute
/// values to replace the existing attribute values. For example, if an item <code>I</code>
/// has the attributes <code>{ 'a', '1' }, { 'b', '2'}</code> and <code>{ 'b', '3' }</code>
/// and the requester does a BatchPutAttributes of <code>{'I', 'b', '4' }</code> with
/// the Replace parameter set to true, the final attributes of the item will be <code>{
/// 'a', '1' }</code> and <code>{ 'b', '4' }</code>, replacing the previous values of
/// the 'b' attribute with the new value.
/// </para>
/// <important> This operation is vulnerable to exceeding the maximum URL size when making
/// a REST request using the HTTP GET method. This operation does not support conditions
/// using <code>Expected.X.Name</code>, <code>Expected.X.Value</code>, or <code>Expected.X.Exists</code>.
/// </important>
/// <para>
/// You can execute multiple <code>BatchPutAttributes</code> operations and other operations
/// in parallel. However, large numbers of concurrent <code>BatchPutAttributes</code>
/// calls can result in Service Unavailable (503) responses.
/// </para>
///
/// <para>
/// The following limitations are enforced for this operation: <ul> <li>256 attribute
/// name-value pairs per item</li> <li>1 MB request size</li> <li>1 billion attributes
/// per domain</li> <li>10 GB of total user data storage per domain</li> <li>25 item limit
/// per <code>BatchPutAttributes</code> operation</li> </ul>
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes service method.</param>
///
/// <returns>The response from the BatchPutAttributes service method, as returned by SimpleDB.</returns>
/// <exception cref="DuplicateItemNameException">
/// The item name was specified more than once.
/// </exception>
/// <exception cref="InvalidParameterValueException">
/// The value for a parameter is invalid.
/// </exception>
/// <exception cref="MissingParameterException">
/// The request must contain the specified missing parameter.
/// </exception>
/// <exception cref="NoSuchDomainException">
/// The specified domain does not exist.
/// </exception>
/// <exception cref="NumberDomainAttributesExceededException">
/// Too many attributes in this domain.
/// </exception>
/// <exception cref="NumberDomainBytesExceededException">
/// Too many bytes in this domain.
/// </exception>
/// <exception cref="NumberItemAttributesExceededException">
/// Too many attributes in this item.
/// </exception>
/// <exception cref="NumberSubmittedAttributesExceededException">
/// Too many attributes exist in a single call.
/// </exception>
/// <exception cref="NumberSubmittedItemsExceededException">
/// Too many items exist in a single call.
/// </exception>
public BatchPutAttributesResponse BatchPutAttributes(BatchPutAttributesRequest request)
{
var marshaller = new BatchPutAttributesRequestMarshaller();
var unmarshaller = BatchPutAttributesResponseUnmarshaller.Instance;
return Invoke<BatchPutAttributesRequest,BatchPutAttributesResponse>(request, marshaller, unmarshaller);
}
IAsyncResult invokeBatchPutAttributes(BatchPutAttributesRequest batchPutAttributesRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new BatchPutAttributesRequestMarshaller().Marshall(batchPutAttributesRequest);
var unmarshaller = BatchPutAttributesResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// Initiates the asynchronous execution of the BatchPutAttributes operation.
/// <seealso cref="Amazon.SimpleDB.IAmazonSimpleDB.BatchPutAttributes"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<BatchPutAttributesResponse> BatchPutAttributesAsync(BatchPutAttributesRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new BatchPutAttributesRequestMarshaller();
var unmarshaller = BatchPutAttributesResponseUnmarshaller.GetInstance();
return Invoke<IRequest, BatchPutAttributesRequest, BatchPutAttributesResponse>(request, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the BatchPutAttributes operation.
/// <seealso cref="Amazon.SimpleDB.IAmazonSimpleDB"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the BatchPutAttributes operation on AmazonSimpleDBClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndBatchPutAttributes
/// operation.</returns>
public IAsyncResult BeginBatchPutAttributes(BatchPutAttributesRequest request, AsyncCallback callback, object state)
{
var marshaller = new BatchPutAttributesRequestMarshaller();
var unmarshaller = BatchPutAttributesResponseUnmarshaller.Instance;
return BeginInvoke<BatchPutAttributesRequest>(request, marshaller, unmarshaller,
callback, state);
}
