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

<p><b>Note</b>: This method needs to be called right before an apolloCall is executed.</p>
11806
void registerCall(@NotNull ApolloCall call) {
    checkNotNull(call, "call == null");
    Operation operation = call.operation();
    if (operation instanceof Query) {
      registerQueryCall((ApolloQueryCall) call);
    } else if (operation instanceof Mutation) {
      registerMutationCall((ApolloMutationCall) call);
    } else {
      throw new IllegalArgumentException("Unknown call type");
    }
  }
553591
void registerQueryWatcher(@NotNull ApolloQueryWatcher queryWatcher) {
    checkNotNull(queryWatcher, "queryWatcher == null");
    OperationName operationName = queryWatcher.operation().name();
    registerCall(activeQueryWatchers, operationName, queryWatcher);
  }
1040155
protected void addNode( Node nodeToInsert, Node insertBeforeNode )
    {
        // Insert node.
        nodeToInsert.next = insertBeforeNode;
        nodeToInsert.previous = insertBeforeNode.previous;
        insertBeforeNode.previous.next = nodeToInsert;
        insertBeforeNode.previous = nodeToInsert;
    }
1280583
public void add(byte[] bytes) {

        if (m_completed) {
            return;
        }
        if (m_redirectTarget == null) {
            // Add only if not already redirected
            m_elements.add(bytes);
            m_byteSize += CmsMemoryMonitor.getMemorySize(bytes);
        }
    }
507678
private void addPendingChange(String key, JsonValue value) {
        if (this.pendingChanges == null) {
            this.pendingChanges = new JsonObject();
        }

        this.pendingChanges.set(key, value);
    }
1280217
public void addLast(final T node) {
        if ( this.firstNode == null ) {
            this.firstNode = node;
            this.lastNode = node;
        } else {
            T currentLast = this.lastNode;
            currentLast.setNext( node );
            node.setPrevious( currentLast );
            this.lastNode = node;            
        }
        
        this.size++;
    }
924451
@Override
    public void add(int arg0, Object arg1) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.entry(this, tc, "add", new Object[] { Integer.valueOf(arg0), arg1 });

        synchronized (getMessageLockArtefact()) {
            super.add(arg0, arg1);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.exit(this, tc, "add");
    }
154881
void registerPrefetchCall(@NotNull ApolloPrefetch apolloPrefetch) {
    checkNotNull(apolloPrefetch, "apolloPrefetch == null");
    OperationName operationName = apolloPrefetch.operation().name();
    registerCall(activePrefetchCalls, operationName, apolloPrefetch);
  }
664882
public void addPayload(IoBuffer additionalPayload) {
        if (payload == null) {
            payload = IoBuffer.allocate(additionalPayload.remaining());
            payload.setAutoExpand(true);
        }
        this.payload.put(additionalPayload);
    }
681915
synchronized public void addAppender(Appender appender) throws IllegalArgumentException {
        if (appender == null) {
            throw new IllegalArgumentException("Appender not allowed to be null");
        }

        for (Appender p : appenderList) {
            if (p.getClass() == appender.getClass())
                return;
        }
        appenderList.add(appender);
    }
649230
public MatcherController add(MatcherPattern matcherPattern) {
        int patternCode = matcherPattern.getPatternCode();

        if (this.lastAddTableInfo == null) {
            throw new IllegalStateException("There is a problem with the order of function call.");
        }

        if (findMatcherPattern(patternCode) != null) {
            throw new IllegalArgumentException("patternCode has been specified already exists.");
        }

        this.matcherPatterns.add(matcherPattern);
        return this;
    }
300635
@Override
    @Deprecated
    public boolean add(T t) {
        try {
            return addSync(t);
        } finally {
            if(extensions!=null) {
                fireOnChangeListeners();
            }
        }
    }
500058
static Node newCallNode(Node callTarget, Node... parameters) {
    boolean isFreeCall = !isGet(callTarget);
    Node call = IR.call(callTarget);
    call.putBooleanProp(Node.FREE_CALL, isFreeCall);
    for (Node parameter : parameters) {
      call.addChildToBack(parameter);
    }
    return call;
  }
1044049
public void add(Versioned<E> arg0) {
        _lastId = VStack.NULL_ID;
        _lastCall = LastCall.ADD;
        throw new UnsupportedOperationException();
    }
1354918
@NotNull Set<ApolloMutationCall> activeMutationCalls(@NotNull OperationName operationName) {
    return activeCalls(activeMutationCalls, operationName);
  }
993199
public static void addArgument(MethodCallExpr call, Expression arg) {
        List<Expression> args = call.getArgs();
        if (args == null) {
            args = new ArrayList<Expression>();
            call.setArgs(args);
        }
        args.add(arg);
    }
170678
private void addPermanent(IzouSoundLineBaseClass izouSoundLine) {
        debug("adding " + izouSoundLine + " to permanent");
        if (!izouSoundLine.isPermanent())
            izouSoundLine.setToPermanent();
        synchronized (permanentUserReadWriteLock) {
            endWaitingForUsage();
            if (permanentLines == null) {
                permanentLines = Collections.synchronizedList(new ArrayList<>());
            }
            permanentLines.add(new WeakReference<>(izouSoundLine));
        }
        //TODO: STOP the addon via the stop event
    }