<p>Adds provided {@link ApolloQueryWatcher} that is currently in progress.</p>

<p><b>Note</b>: This method needs to be called right before
{@link ApolloQueryWatcher#enqueueAndWatch(ApolloCall.Callback)}.</p>
553591
void registerQueryWatcher(@NotNull ApolloQueryWatcher queryWatcher) {
    checkNotNull(queryWatcher, "queryWatcher == null");
    OperationName operationName = queryWatcher.operation().name();
    registerCall(activeQueryWatchers, operationName, queryWatcher);
  }
1212868
public static void addCompleter(BiConsumer<Map<Object,Object>,Long> completer)
    {
        Thread currentThread = Thread.currentThread();
        if (currentThread instanceof TaggableThread)
        {
            TaggableThread taggableThread = (TaggableThread) currentThread;
            taggableThread.addMe(completer);
        }
    }
227256
public <T extends VoidMessage> void addPrecursor(@NonNull Class<T> cls, @NonNull MessageCallable<T> callable) {
        precursors.put(cls.getCanonicalName(), callable);
    }
1061728
public void addPagingBehavior(PagingBehavior pagingBehavior) {
		checkInitialized();

		// avoid adding the same type(!) of behavior twice, error out if that's the case
		boolean behaviorTypeAdded = pagingBehaviors
				.stream()
				.anyMatch(pbh -> pbh.getClass().equals(pagingBehavior.getClass()));

		if (!behaviorTypeAdded) {
			pagingBehaviors.add(pagingBehavior);
		}
		else {
			throw new IllegalArgumentException(
					"PagingBehavior of same type already added. Type:"
							+ pagingBehavior.getClass().getSimpleName());
		}
	}
1131461
@NotNull public static Completable from(@NotNull final ApolloPrefetch prefetch) {
    checkNotNull(prefetch, "prefetch == null");

    return Completable.create(new CompletableOnSubscribe() {
      @Override public void subscribe(final CompletableEmitter emitter) {
        cancelOnCompletableDisposed(emitter, prefetch);
        prefetch.enqueue(new ApolloPrefetch.Callback() {
          @Override public void onSuccess() {
            if (!emitter.isDisposed()) {
              emitter.onComplete();
            }
          }

          @Override public void onFailure(@NotNull ApolloException e) {
            Exceptions.throwIfFatal(e);
            if (!emitter.isDisposed()) {
              emitter.onError(e);
            }
          }
        });
      }
    });
  }
138425
public void addListener(final NodeTypeManagerListener listener)
   {
      if (!this.listeners.containsKey(listener))
      {
         this.listeners.put(listener, listener);
      }
   }
166852
@Override
  public void addCreateListener( AsyncCallback<T> callback )
  {
    DataSubscription subscription = new DataSubscription( RTDataEvents.created, tableName, createCallback( callback ) );
    addEventListener( subscription );
  }
1289079
public <T extends IEntity> void addAsync(T entity, CallbackHandler callbackHandler) throws FMSException {

        IntuitMessage intuitMessage = prepareAdd(entity);

        //set callback handler
        intuitMessage.getRequestElements().setCallbackHandler(callbackHandler);

        //execute async interceptors
        executeAsyncInterceptors(intuitMessage);
    }
289514
public void addCallback(final ClientTransport.PingCallback callback, Executor executor) {
    Runnable runnable;
    synchronized (this) {
      if (!completed) {
        callbacks.put(callback, executor);
        return;
      }
      // otherwise, invoke callback immediately (but not while holding lock)
      runnable = this.failureCause != null ? asRunnable(callback, failureCause)
                                           : asRunnable(callback, roundTripTimeNanos);
    }
    doExecute(executor, runnable);
  }
605474
@Override
  public FutureResultImpl<T> setHandler(Handler<AsyncResult<T>> handler) {
    this.handler = handler;
    checkCallHandler();
    return this;
  }
724665
@NotNull Set<ApolloQueryWatcher> activeQueryWatchers(@NotNull OperationName operationName) {
    return activeCalls(activeQueryWatchers, operationName);
  }
350107
private static synchronized void addTransformer() {
        if (detailedTransformTrace && tc.isEntryEnabled())
            Tr.entry(tc, "addTransformer");

        if (registeredTransformer == null && instrumentation != null) {
            registeredTransformer = new LibertyJava8WorkaroundRuntimeTransformer();
            instrumentation.addTransformer(registeredTransformer, false);
        }

        if (detailedTransformTrace && tc.isEntryEnabled())
            Tr.exit(tc, "addTransformer");
    }
1211868
@Override
    public synchronized void addCallBack(RecoveryLogCallBack callback) {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "addCallBack", callback);

        if (_registeredCallbacks == null) {
            _registeredCallbacks = new HashSet<RecoveryLogCallBack>();
        }

        _registeredCallbacks.add(callback);

        if (tc.isEntryEnabled())
            Tr.exit(tc, "addCallBack");
    }
547038
private void startWatcher() {

        if (m_watcher == null) {
            try {
                m_watcher = new CmsUploadTimeoutWatcher(this);
                m_watcher.start();
            } catch (Exception e) {
                LOG.info(
                    Messages.get().getBundle().key(Messages.LOG_UPLOAD_CREATE_WATCH_DOG_2, getId(), e.getMessage()));
            }
        }
    }
421404
public void addForeignWatch(TableKraken table, byte []key, String serverId)
  {
    WatchForeign watch = new WatchForeign(key, table, serverId);

    WatchTable watchTable = getWatchTable(table);
    
    watchTable.addWatchForeign(watch, key);
  }
843831
public int addWatcher(TextWatcher watcher){
        int id = mWatchers.size();
        addWatcher(id, watcher);
        return id;
    }
383541
@Deprecated
    public void addWatcher(File file, Watcher watcher) {
        addWatcher(file.toPath(), watcher);
    }