public InMemoryQueuePersistor() { this.offerFun = new MapOfferFunction(); this.getFun = new MapGetFunction(); this.removeFun = new MapRemoveFunction(); }
/** * Close the underlying {@link reactor.queue.QueuePersistor} and release any resources. */ public void close() { persistor.close(); }
@SuppressWarnings("unchecked") @Override public T next() { return fn.get(); }
protected AbstractMultiThreadDispatcher(int numberThreads, int backlog) { this.backlog = backlog; this.numberThreads = numberThreads; this.taskFactory = new BatchFactorySupplier<MultiThreadTask>( backlog, new Supplier<MultiThreadTask>() { @Override public MultiThreadTask get() { return new MultiThreadTask(); } } ); this.recursiveTasks = BlockingQueueFactory.createQueue(); }
offerFun = new ChronicleOfferFunction(); getFun = new ChronicleGetFunction(); removeFun = new ChronicleRemoveFunction(data.createTailer());
@Override public PersistentQueue<T> get() { try { return new PersistentQueue<T>(new IndexedChronicleQueuePersistor<T>(basePath, codec, clearOnStart, deleteOnExit, config)); } catch(IOException e) { throw new IllegalStateException(e.getMessage(), e); } }
@Override public boolean hasNext() { return removeFun.hasNext(); }
@Override public int size() { return (int)persistor.size(); }
/** * Create a {@literal PersistentQueue} using the given {@link QueuePersistor}. * * @param persistor */ public PersistentQueue(@Nullable QueuePersistor<T> persistor) { this.persistor = (null == persistor ? new InMemoryQueuePersistor<T>() : persistor); }
@Nonnull public Iterator<T> iterator() { return persistor.iterator(); }
@Override public boolean offer(T obj) { return (null != persistor.offer().apply(obj)); }
@Override public Iterator<T> iterator() { final ChronicleRemoveFunction fn; try { fn = new ChronicleRemoveFunction(data.createTailer()); } catch(IOException e) { throw new IllegalStateException(e.getMessage(), e); } return new Iterator<T>() { public boolean hasNext() { return fn.hasNext(); } @SuppressWarnings("unchecked") @Override public T next() { return fn.get(); } @Override public void remove() { throw new IllegalStateException("This Iterator is read-only."); } }; }
protected AbstractTcpConnection(Environment env, Codec<Buffer, IN, OUT> codec, Dispatcher ioDispatcher, Dispatcher eventsDispatcher) { this.env = env; this.ioDispatcher = ioDispatcher; this.ioReactor = Reactors.reactor(env, ioDispatcher); this.eventsReactor = Reactors.reactor(env, eventsDispatcher); if(null != codec) { this.decoder = codec.decoder(new NotifyConsumer<IN>(read.getT2(), eventsReactor)); this.encoder = codec.encoder(); } else { this.decoder = null; this.encoder = null; } this.replyToKeys = BlockingQueueFactory.createQueue(); consume(new Consumer<IN>() { @Override public void accept(IN in) { try { AbstractTcpConnection.this.eventsReactor.notify(replyToKeys.remove(), Event.wrap(in)); } catch(NoSuchElementException ignored) { } } }); }
public boolean hasNext() { return fn.hasNext(); }
this.encoder = null; this.replyToKeys = BlockingQueueFactory.createQueue();