Simplified method form for invoking the DescribeReservedInstancesOfferings operation with an AsyncHandler.

@see #describeReservedInstancesOfferingsAsync(DescribeReservedInstancesOfferingsRequest,
com.amazonaws.handlers.AsyncHandler)
969733
@Override
    public java.util.concurrent.Future<DescribeReservedInstancesOfferingsResult> describeReservedInstancesOfferingsAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeReservedInstancesOfferingsRequest, DescribeReservedInstancesOfferingsResult> asyncHandler) {

        return describeReservedInstancesOfferingsAsync(new DescribeReservedInstancesOfferingsRequest(), asyncHandler);
    }
500224
@Override
    public java.util.concurrent.Future<UpdateApplicationResult> updateApplicationAsync(
            com.amazonaws.handlers.AsyncHandler<UpdateApplicationRequest, UpdateApplicationResult> asyncHandler) {

        return updateApplicationAsync(new UpdateApplicationRequest(), asyncHandler);
    }
944025
@Override
    public java.util.concurrent.Future<DescribeReplicationGroupsResult> describeReplicationGroupsAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeReplicationGroupsRequest, DescribeReplicationGroupsResult> asyncHandler) {

        return describeReplicationGroupsAsync(new DescribeReplicationGroupsRequest(), asyncHandler);
    }
528274
@Override
    public java.util.concurrent.Future<ListPublicKeysResult> listPublicKeysAsync(
            com.amazonaws.handlers.AsyncHandler<ListPublicKeysRequest, ListPublicKeysResult> asyncHandler) {

        return listPublicKeysAsync(new ListPublicKeysRequest(), asyncHandler);
    }
1140648
@Override
    public void runIsolatedAsynch(boolean deliverImmediately) throws SIIncorrectCallException, SISessionUnavailableException, SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "runIsolatedAsynch", new Object[] { this, Boolean.valueOf(deliverImmediately) });

        synchronized (_asynchConsumerBusyLock)
        {
            // Lock the consumer session while we check that it is in a valid
            // state
            this.lock();
            try
            {
                // Only valid if the consumer session is still open
                checkNotClosed();

                //if there is no callback registered, throw an exception
                if (!_asynchConsumerRegistered)
                {
                    SIIncorrectCallException e =
                                    new SIIncorrectCallException(
                                                    nls.getFormattedMessage(
                                                                            "ASYNCH_CONSUMER_ERROR_CWSIP0175",
                                                                            new Object[] { _consumerDispatcher.getDestination().getName(),
                                                                                          _messageProcessor.getMessagingEngineName() },
                                                                            null));

                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        SibTr.exit(tc, "runIsolatedAsynch", e);

                    throw e;
                }
                // we can't do an isolated run if the LCP is not in a stopped state
                // so throw an exception
                if (!_stopped)
                {
                    SIIncorrectCallException e =
                                    new SIIncorrectCallException(
                                                    nls.getFormattedMessage(
                                                                            "ASYNCH_CONSUMER_RUN_ERROR_CWSIP0176",
                                                                            new Object[] { _consumerDispatcher.getDestination().getName(),
                                                                                          _consumerDispatcher.getMessageProcessor().getMessagingEngineName() },
                                                                            null));

                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        SibTr.exit(tc, "runIsolatedAsynch", e);
                    throw e;
                }

                // If the consumer has been stopped because the destination is not
                // allowing consumers to get messages then we simply return.
                if (_stoppedForReceiveAllowed)
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        SibTr.exit(tc, "runIsolatedAsynch", "Receive not allowed");

                    return;
                }
            } // synchronized (this)
            finally
            {
                this.unlock();
            }
        } // synchronized (asynchConsumer)

        //if we get this far then if deliverImmediately is set then this
        //implies that the callback should be inline
        if (deliverImmediately)
        {
            //run the asynch inline
            try
            {
                runAsynchConsumer(true);
            } catch (Throwable e)
            {
                FFDCFilter.processException(
                                            e,
                                            "com.ibm.ws.sib.processor.impl.JSLocalConsumerPoint.runIsolatedAsynch",
                                            "1:3182:1.22.5.1",
                                            this);

                SibTr.exception(tc, e);

                try
                {
                    // Since the asynchConsumer has experienced an error of some kind, the best form
                    // of cleanup is to close down the session. This ensures any listeners get notified
                    // and can retry at some point later.
                    _consumerSession.close();
                    // don't notify asynchconsumer as we are been called inline
                } catch (Exception ee)
                {
                    // No FFDC code needed
                    SibTr.exception(tc, ee);
                }

                if (e instanceof ThreadDeath)
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                        SibTr.exit(tc, "runIsolatedAsynch", e);
                    throw (ThreadDeath) e;
                }

                SISessionDroppedException sessionDroppedException = new SISessionDroppedException(
                                nls.getFormattedMessage("CONSUMER_CLOSED_ERROR_CWSIP0177"
                                                        , new Object[] { _consumerDispatcher.getDestination().getName(),
                                                                        _messageProcessor.getMessagingEngineName() }
                                                        , null), e);

                if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                    SibTr.exit(tc, "runIsolatedAsynch", sessionDroppedException);

                //inline call so throwing exception rather than notifying
                throw sessionDroppedException;
            }
        }
        else
        {
            //start up a new thread (from the MP's thread pool)
            //to deliver the message asynchronously
            try
            {
                _messageProcessor.startNewThread(new AsynchThread(this, true));
            } catch (InterruptedException e)
            {
                // No FFDC code needed

                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    SibTr.debug(tc, "runIsolatedAsynch", e);
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "runIsolatedAsynch");
    }
546084
@Override
    public java.util.concurrent.Future<DescribeVpnConnectionsResult> describeVpnConnectionsAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeVpnConnectionsRequest, DescribeVpnConnectionsResult> asyncHandler) {

        return describeVpnConnectionsAsync(new DescribeVpnConnectionsRequest(), asyncHandler);
    }
703033
@Override
    public java.util.concurrent.Future<DescribeConversionTasksResult> describeConversionTasksAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeConversionTasksRequest, DescribeConversionTasksResult> asyncHandler) {

        return describeConversionTasksAsync(new DescribeConversionTasksRequest(), asyncHandler);
    }
529810
@Override
    public java.util.concurrent.Future<DescribeSeverityLevelsResult> describeSeverityLevelsAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeSeverityLevelsRequest, DescribeSeverityLevelsResult> asyncHandler) {

        return describeSeverityLevelsAsync(new DescribeSeverityLevelsRequest(), asyncHandler);
    }
800077
@Override
    public java.util.concurrent.Future<ListHostedZonesResult> listHostedZonesAsync(
            com.amazonaws.handlers.AsyncHandler<ListHostedZonesRequest, ListHostedZonesResult> asyncHandler) {

        return listHostedZonesAsync(new ListHostedZonesRequest(), asyncHandler);
    }
1313601
@Override
    public java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(String queueUrl, java.util.List<String> attributeNames,
            com.amazonaws.handlers.AsyncHandler<GetQueueAttributesRequest, GetQueueAttributesResult> asyncHandler) {

        return getQueueAttributesAsync(new GetQueueAttributesRequest().withQueueUrl(queueUrl).withAttributeNames(attributeNames), asyncHandler);
    }
658736
public void setReservedInstancesOfferings(java.util.Collection<ReservedInstancesOffering> reservedInstancesOfferings) {
        if (reservedInstancesOfferings == null) {
            this.reservedInstancesOfferings = null;
            return;
        }

        this.reservedInstancesOfferings = new com.amazonaws.internal.SdkInternalList<ReservedInstancesOffering>(reservedInstancesOfferings);
    }
1171718
public static void asyncUnimplementedUnaryCall(
      MethodDescriptor<?, ?> methodDescriptor, StreamObserver<?> responseObserver) {
    checkNotNull(methodDescriptor, "methodDescriptor");
    checkNotNull(responseObserver, "responseObserver");
    responseObserver.onError(Status.UNIMPLEMENTED
        .withDescription(String.format("Method %s is unimplemented",
            methodDescriptor.getFullMethodName()))
        .asRuntimeException());
  }
598911
@Override
    public java.util.concurrent.Future<DescribeReservedNodeOfferingsResult> describeReservedNodeOfferingsAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeReservedNodeOfferingsRequest, DescribeReservedNodeOfferingsResult> asyncHandler) {

        return describeReservedNodeOfferingsAsync(new DescribeReservedNodeOfferingsRequest(), asyncHandler);
    }
1273017
@Override
    public java.util.concurrent.Future<ListRolesResult> listRolesAsync(com.amazonaws.handlers.AsyncHandler<ListRolesRequest, ListRolesResult> asyncHandler) {

        return listRolesAsync(new ListRolesRequest(), asyncHandler);
    }
545383
@Override
    public java.util.concurrent.Future<ListVirtualMFADevicesResult> listVirtualMFADevicesAsync(
            com.amazonaws.handlers.AsyncHandler<ListVirtualMFADevicesRequest, ListVirtualMFADevicesResult> asyncHandler) {

        return listVirtualMFADevicesAsync(new ListVirtualMFADevicesRequest(), asyncHandler);
    }
673282
@Override
    public java.util.concurrent.Future<DescribeStreamResult> describeStreamAsync(String streamName, Integer limit, String exclusiveStartShardId,
            com.amazonaws.handlers.AsyncHandler<DescribeStreamRequest, DescribeStreamResult> asyncHandler) {

        return describeStreamAsync(new DescribeStreamRequest().withStreamName(streamName).withLimit(limit).withExclusiveStartShardId(exclusiveStartShardId),
                asyncHandler);
    }
768413
@Override
    public java.util.concurrent.Future<DescribeWorkspaceDirectoriesResult> describeWorkspaceDirectoriesAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeWorkspaceDirectoriesRequest, DescribeWorkspaceDirectoriesResult> asyncHandler) {

        return describeWorkspaceDirectoriesAsync(new DescribeWorkspaceDirectoriesRequest(), asyncHandler);
    }