Simplified method form for invoking the GetQueueUrl operation.

@see #getQueueUrlAsync(GetQueueUrlRequest)
768608
@Override
    public java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(String queueName) {

        return getQueueUrlAsync(new GetQueueUrlRequest().withQueueName(queueName));
    }
48357
@Deprecated
    protected Runnable getTask(boolean oldThread) throws InterruptedException { // PK77809
        long waitTime;
        Runnable r = null;
        boolean firstTime = true;

        while (true) {
            synchronized (this) {
                // System.out.println("1 " + activeThreads + " : " + poolSize_);
                if (firstTime) {
                    --activeThreads;

                    // PK77809 Let the buffer know we have a waiting thread
                    if (oldThread) {
                        requestBuffer.incrementWaitingThreads();
                    }

                }

                if (poolSize_ > maximumPoolSize_) {
                    // Cause to die if too many threads
                    if (!growasneeded || !firstTime) {
                        // System.out.println("2 die");
                        --poolSize_;

                        // PK77809 Let the buffer know we have a waiting thread
                        requestBuffer.decrementWaitingThreads();

                        return null;
                    }
                }

                // infinite timeout if we are below the minimum size
                waitTime = (shutdown_) ? 0 : (poolSize_ <= minimumPoolSize_) ? -1 : keepAliveTime_;
            }

            // PK27301 start
            try {
                r = (waitTime >= 0) ? (Runnable) (requestBuffer.poll(waitTime)) : (Runnable) (requestBuffer.take());
            } catch (InterruptedException e) {
                ++activeThreads;

                // PK77809 Let the buffer know we have a waiting thread
                synchronized (this) {
                    requestBuffer.decrementWaitingThreads();
                };

                throw e;
            }
            // PK27301 end

            synchronized (this) {
                // System.out.println("3 r=" + r);
                if (r == null) {
                    r = (Runnable) requestBuffer.poll(0);
                }
                if (r != null) {
                    ++activeThreads;
                    break;
                } else if (poolSize_ > minimumPoolSize_) {
                    // discount the current thread
                    // System.out.println("4 die");
                    poolSize_--;

                    // PK77809 Signal the buffer we have removed a thread
                    requestBuffer.decrementWaitingThreads();

                    break;
                }
                // System.out.println("going again");
            }

            firstTime = false;
        }

        return r;
    }
223522
public function getQueueUrl($queue = null)
    {
        $queue = $queue ?: $this->queue;

        if (filter_var($queue, FILTER_VALIDATE_URL) !== false) {
            return $queue;
        }

        return $this->client->getQueueUrl(['QueueName' => $queue])->get('QueueUrl');
    }
790178
protected Queue<AsyncResourceRequest<V>> getRequestQueueForKey(K key) {
        Queue<AsyncResourceRequest<V>> requestQueue = requestQueueMap.get(key);
        if(requestQueue == null) {
            Queue<AsyncResourceRequest<V>> newRequestQueue = new ConcurrentLinkedQueue<AsyncResourceRequest<V>>();
            requestQueue = requestQueueMap.putIfAbsent(key, newRequestQueue);
            if(requestQueue == null) {
                requestQueue = newRequestQueue;
            }
        }
        return requestQueue;
    }
1158020
@Override
    public StringBuffer getRequestURL() {
        try {
            collaborator.preInvoke(componentMetaData);
            return request.getRequestURL();
        } finally {
            collaborator.postInvoke();
        }
    }
352035
private AbstractInvocation dequeue() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dequeue");

    AbstractInvocation invocation;

    synchronized (barrier) {
      invocation = queue.remove(0);
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dequeue", invocation);
    return invocation;
  }
1365174
public void enqueueURL(VisitState visitState, final ByteArrayList url) throws IOException {
		final byte[] urlBuffer = url.elements();
		final int pathQueryStart = BURL.startOfpathAndQuery(urlBuffer);
		byteArrayDiskQueues.enqueue(visitState,  urlBuffer, pathQueryStart, url.size() - pathQueryStart);
	}
762514
@Override
    public java.util.concurrent.Future<DescribeCustomerGatewaysResult> describeCustomerGatewaysAsync(
            com.amazonaws.handlers.AsyncHandler<DescribeCustomerGatewaysRequest, DescribeCustomerGatewaysResult> asyncHandler) {

        return describeCustomerGatewaysAsync(new DescribeCustomerGatewaysRequest(), asyncHandler);
    }
921107
protected Queue<AsyncResourceRequest<V>> getRequestQueueForExistingKey(K key) {
        Queue<AsyncResourceRequest<V>> requestQueue = requestQueueMap.get(key);
        return requestQueue;
    }
984252
@Override
    public java.util.concurrent.Future<DeleteQueueResult> deleteQueueAsync(String queueUrl) {

        return deleteQueueAsync(new DeleteQueueRequest().withQueueUrl(queueUrl));
    }
404831
@SuppressWarnings("deprecation")
    @Override
    public String get(Run<?, ?> run, TaskListener listener) {
        return DisplayURLProvider.get().getRunURL(run);
    }
485570
private URL getUrl() {
		ClassLoader loader = Thread.currentThread().getContextClassLoader();
		URL url = loader.getResource(this.getPath());
		return url;
	}
478076
public QueueBufferFuture<ReceiveMessageRequest, ReceiveMessageResult> receiveMessageAsync(ReceiveMessageRequest rq,
                                                                                              QueueBufferCallback<ReceiveMessageRequest, ReceiveMessageResult> callback) {
        if (shutDown) {
            throw new AmazonClientException("The client has been shut down.");
        }

        // issue the future...
        int numMessages = 10;
        if (rq.getMaxNumberOfMessages() != null) {
            numMessages = rq.getMaxNumberOfMessages();
        }
        QueueBufferFuture<ReceiveMessageRequest, ReceiveMessageResult> toReturn = issueFuture(numMessages, callback);

        // attempt to satisfy it right away...
        satisfyFuturesFromBuffer();

        // spawn more receive tasks if we need them...
        spawnMoreReceiveTasks();

        return toReturn;
    }
919371
public static <E> BlockingQueue<E> getLimitedBlockingQueue(int maxQueue) {
        return new LinkedBlockingQueue<E>(maxQueue) {
            @Override
            public boolean offer(E e) {
                return putInsteadOfOffer(this, e);
            }
        };
    }
818801
@Override
	public QueueDefinition getQueue(String queueName) {
		if (!StringUtils.hasText(queueName)) {
			return null;
		}
		for (QueueDefinition qd: m_queues) {
			if (qd.getName().equals(queueName)) {
				return qd;
			}
		}
		log.warn("failed to find queue: {}", queueName);
		return null;
	}
642044
function QueueEntry(url, success, error, queue) {
    var _this = this;

    // A list of callbacks that will be called. Supports multiple callbacks.
    this.callbacks = {
        success: [success],
        error: [error]
        /**
         * @type {string}
         */
    };this.url = url;
    /**
     * Passes all the arguments to LoadSuccess
     * @type {function}
     */
    this.success = function () {
        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
        }

        runCallbacks(_this.callbacks.success, function (callback) {
            callback.apply(undefined, [url].concat(args));
        });
    };
    /**
     * @type {function}
     * @param {Error} errorObject
     */
    this.error = function (errorObject) {
        runCallbacks(_this.callbacks.success, function (callback) {
            callback(url, errorObject);
        });
    };

    /**
     * Cancels loading - removes the image
     */
    this.cancel = function () {
        queue.cancel(_this);
    };

    /**
     * @type {LoadTask|null}
     */
    this.task = null;
}
659585
private void fetch() {
    	next.clear();
        // We need to remember for what thread the IEnumVARIANT was marshaled. Because if we want to interpret this
        // VARIANT as an interface pointer later on, we need to do this in the same thread!
        next.thread = e.getComThread();
        int r = e.next(1,next);
        if(r==0) {
            next = null;
            e.dispose();
        }
    }