@javatypes/amqp-client

Version:

java amqp-client types

96 lines (95 loc) • 5.75 kB

TypeScript

declare namespace com { namespace rabbitmq { namespace client { namespace impl { /** * This is a generic implementation of the channels specification * in Channeling Work, Nov 2010 (<tt>channels.pdf</tt>). * Objects of type K must be registered, with <code>registerKey(K)</code>, * and then they become clients and a queue of * items (type W) is stored for each client. * * Each client has a state which is exactly one of dormant, * in progress or ready. Immediately after registration a client is dormant. * Items may be (singly) added to (the end of) a client's queue with {@link WorkPool#addWorkItem(Object, Object)}. * If the client is dormant it becomes ready thereby. All other states remain unchanged. * The next ready client, together with a collection of its items, * may be retrieved with <code>nextWorkBlock(collection,max)</code> * (making that client in progress). * An in progress client can finish (processing a batch of items) with <code>finishWorkBlock(K)</code>. * It then becomes either dormant or ready, depending if its queue of work items is empty or no. * If a client has items queued, it is either in progress or ready but cannot be both. * When work is finished it may be marked ready if there is further work, * or dormant if there is not. * There is never any work for a dormant client. * A client may be unregistered, with <code>unregisterKey(K)</code>, which removes the client from * all parts of the state, and any queue of items stored with it. * All clients may be unregistered with <code>unregisterAllKeys()</code>. * <h2>Concurrent Semantics</h2> * This implementation is thread-safe. * @param <K> Key -- type of client * @param <W> Work -- type of work item */ // @ts-ignore class WorkPool<K, W> extends java.lang.Object { // @ts-ignore constructor(queueingTimeout: number /*int*/) /** * Add client <code>key</code> to pool of item queues, with an empty queue. * A client is initially dormant. * No-op if <code>key</code> already present. * @param key client to add to pool */ // @ts-ignore public registerKey(key: K): void // @ts-ignore public limit(key: K): void // @ts-ignore public unlimit(key: K): void /** * Remove client from pool and from any other state. Has no effect if client already absent. * @param key of client to unregister */ // @ts-ignore public unregisterKey(key: K): void /** * Remove all clients from pool and from any other state. */ // @ts-ignore public unregisterAllKeys(): void /** * Return the next ready client, * and transfer a collection of that client's items to process. * Mark client in progress. * If there is no ready client, return <code>null</code>. * @param to collection object in which to transfer items * @param size max number of items to transfer * @return key of client to whom items belong, or <code>null</code> if there is none. */ // @ts-ignore public nextWorkBlock(to: java.util.Collection<W> | Array<W>, size: number /*int*/): K /** * Add (enqueue) an item for a specific client. * No change and returns <code>false</code> if client not registered. * If dormant, the client will be marked ready. * @param key the client to add to the work item to * @param item the work item to add to the client queue * @return <code>true</code> if and only if the client is marked ready * — as a result of this work item */ // @ts-ignore public addWorkItem(key: K, item: W): boolean /** * Set client no longer in progress. * Ignore unknown clients (and return <code>false</code>). * @param key client that has finished work * @return <code>true</code> if and only if client becomes ready * @throws IllegalStateException if registered client not in progress */ // @ts-ignore public finishWorkBlock(key: K): boolean } } } } }