@Override
    protected Traverser.Admin<E> processNextStart() {
        if (isStart && first) {
            first = false;

            /*
             * Start of a traversal (no input). Obtain the one-time service iterator.
             */

            if (this.starts.hasNext()) {
                throw new IllegalStateException("This service must be called without input: " + serviceName);
            }

            this.iterator = start();
        }

        while (true) {
            if (this.iterator.hasNext()) {

                /*
                 * Still draining the current iterator.
                 */

                final Object next = this.iterator.next();
                if (next instanceof Traverser.Admin) {
                    /*
                     * Service is producing its own traversers (or is a pass-through on the input). Possible for
                     * streaming or barrier.
                     */
                    return (Traverser.Admin<E>) next;
                } else if (this.head != null) {
                    /*
                     * Streaming service mapping input (head) to non-traverser output. This applies to streaming
                     * service execution only.
                     */
                    return this.head.split((E) next, this);
                } else {
                    /*
                     * Barrier service producing non-traverser output, we have no head to split against. This loses
                     * all path information.
                     */
                    return this.traversal.getTraverserGenerator().generate(next, (Step) this, 1l);
                }
            } else {

                /*
                 * Time to obtain another iterator from upstream input.
                 */

                closeIterator();
                if (!this.starts.hasNext()) {
                    // no more input
                    throw FastNoSuchElementException.instance();
                }
                if (service().isBarrier()) {
                    /*
                     * Barrier service - gather upstream input and call.
                     */
                    final TraverserSet<S> traverserSet = (TraverserSet<S>) this.traversal.getTraverserSetSupplier().get();
                    final int maxBarrierSize = service().getMaxBarrierSize();
                    if (maxBarrierSize == Integer.MAX_VALUE) {
                        // all-at-once
                        this.starts.forEachRemaining(traverserSet::add);
                    } else {
                        // chunked
                        while (this.starts.hasNext() && traverserSet.size() < maxBarrierSize) {
                            traverserSet.add(this.starts.next());
                        }
                    }
                    this.iterator = this.flatMap(traverserSet);
                } else {
                    /*
                     * Streaming service, mark the next start and call.
                     */
                    this.head = this.starts.next();
                    this.iterator = this.flatMap(this.head);
                }
            }
        }
    }
Reference implementation for service calls via the {@link ServiceRegistry} and {@link Service} APIs. This step
can be used to start a traversal or it can be used mid-traversal with one at a time or barrier execution.

@author Mike Personick (http://github.com/mikepersonick)
gremlin-core/src/main/java/org/apache/tinkerpop/gremlin/process/traversal/step/map/CallStep.java