static EagleEyeAppender watch(EagleEyeAppender appender) { watchedAppenders.addIfAbsent(appender); return appender; }
/** * Adds the specified element to this set if it is not already present. * More formally, adds the specified element {@code e} to this set if * the set contains no element {@code e2} such that * <tt>(e==null ? e2==null : e.equals(e2))</tt>. * If this set already contains the element, the call leaves the set * unchanged and returns {@code false}. * * @param e element to be added to this set * @return {@code true} if this set did not already contain the specified * element */ public boolean add(E e) { return al.addIfAbsent(e); }
protected void addBasePaneListener(BasePaneListener<T> basePaneListener) { listeners.addIfAbsent(basePaneListener); }
/*** * * @param robustExtension * 注册RobustExtension监听器,通知当前执行程序 * @return */ public synchronized static boolean register(RobustExtension robustExtension) { if (registerExtensionList == null) { registerExtensionList = new CopyOnWriteArrayList<RobustExtension>(); } return registerExtensionList.addIfAbsent(robustExtension); }
@Override public final void addObserver(EventObserver<BackupEvent> observer) { if (observer == null) throw new NullPointerException("observer must not be null."); observers.addIfAbsent(observer); }
/** * Append the element if not present. * * @return true if the element was added */ public boolean addIfAbsent(IpFilterRule ipFilterRule) { if (ipFilterRule == null) { throw new NullPointerException("IpFilterRule can not be null"); } return ipFilterRuleList.addIfAbsent(ipFilterRule); }
@Override public boolean addIfAbsent(T e) { boolean added = super.addIfAbsent(e); if (added) { syncGroups(e, ADD); } return added; }
/** * get event listener for eventType. Add Entry if not exist. */ static Entry getEntry(Class<? extends Event> eventType) { for (; ; ) { for (Entry entry : LISTENER_HUB) { if (entry.eventType == eventType) { return entry; } } Entry tmp = new Entry(eventType); /** * false means already exists */ if (LISTENER_HUB.addIfAbsent(tmp)) { return tmp; } } }
/** * Create a MessageConsumer. * <p/> * <P>Create a durable consumer to the specified destination * * @param destination Equals to Topic:MessageType in ROCKETMQ * @throws javax.jms.JMSException * @see <CODE>Destination</CODE> */ @Override public MessageConsumer createConsumer(Destination destination) throws JMSException { JmsBaseMessageConsumer messageConsumer = new JmsBaseMessageConsumer(destination, this.context, this.connection); this.consumerList.addIfAbsent(messageConsumer); return messageConsumer; }
/** * Adds group reservation to this partition. * * @param r Reservation. * @return {@code false} If such reservation already added. */ public boolean addReservation(GridDhtPartitionsReservation r) { assert (getPartState(state.get())) != EVICTED : "we can reserve only active partitions"; assert (getReservations(state.get())) != 0 : "partition must be already reserved before adding group reservation"; return reservations.addIfAbsent(r); }
/** * Add listener * * @param listener listener */ public void addListener(Listener listener) { if (null == listener) { throw new IllegalArgumentException("listener is null"); } ManagerListenerWrap wrap = new ManagerListenerWrap(listener); if (listeners.addIfAbsent(wrap)) { log.info(name, "[add-listener] ok, tenant={}, dataId={}, group={}, cnt={}", tenant, dataId, group, listeners.size()); } }
private ManagementRegistration registerServerMXBean(XnioServerMXBean serverMXBean){ serverMetrics.addIfAbsent(serverMXBean); final Closeable handle = NioXnio.register(serverMXBean); return () -> { serverMetrics.remove(serverMXBean); safeClose(handle); }; }
@Override public <R> Registration subscribe(String queryName, Type responseType, MessageHandler<? super QueryMessage<?, R>> handler) { CopyOnWriteArrayList<QuerySubscription> handlers = subscriptions.computeIfAbsent(queryName, k -> new CopyOnWriteArrayList<>()); QuerySubscription<R> querySubscription = new QuerySubscription<>(responseType, handler); handlers.addIfAbsent(querySubscription); return () -> unsubscribe(queryName, querySubscription); }
/** * add event listener */ static public void addEventListener(AbstractEventListener listener) { for (Class<? extends Event> type : listener.interest()) { getEntry(type).listeners.addIfAbsent(listener); } }
/** * 添加事件监听器 */ static public void addEventListener(AbstractEventListener listener) { for (Class<? extends AbstractEvent> type : listener.interest()) { getListenerList(type).addIfAbsent(listener); } }
/** * Associates given {@link Callback}. If callback has been already added, nothing happens. * * @param callback Callback to be associated */ public void addView(final Callback callback) { for (int i = 0; i < mCallbacks.size(); i++) { final CallbackWeakReference reference = mCallbacks.get(i); final Callback item = reference.get(); if (item == null) { // Always remove null references to reduce list size mCallbacks.remove(reference); } } mCallbacks.addIfAbsent(new CallbackWeakReference(callback)); }
/** * add a connection * * @param connection */ public void add(Connection connection) { markAccess(); if (null == connection) { return; } boolean res = this.conns.addIfAbsent(connection); if (res) { connection.increaseRef(); } }
@Override public void onAvailable(final Host host) { this.availableHosts.addIfAbsent(host); }
/** * Attach an appender. If the appender is already in the list in won't be * added again. */ public void addAppender(Appender<E> newAppender) { if (newAppender == null) { throw new IllegalArgumentException("Null argument disallowed"); } appenderList.addIfAbsent(newAppender); }
public synchronized void addRefreshListener(HollowConsumer.RefreshListener refreshListener, HollowConsumer c) { if (refreshListener instanceof HollowConsumer.RefreshRegistrationListener) { if (!refreshListeners.contains(refreshListener)) { ((HollowConsumer.RefreshRegistrationListener)refreshListener).onBeforeAddition(c); } refreshListeners.add(refreshListener); } else { refreshListeners.addIfAbsent(refreshListener); } }