if ( andx != null ) {
            this.andxCommand = (byte) andx.getCommand();
        }
    }


    /**
     * @return the andx
     */
    public final ServerMessageBlock getAndx () {
        return this.andx;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#getNext()
     */
    @Override

            do {
                curReq.setResponse(curResp);

                ServerMessageBlock nextReq = curReq.getAndx();
                if ( nextReq == null ) {
                    break;
                }
                ServerMessageBlock nextResp = curResp.getAndx();
                nextReq.setResponse(nextReq);

        assertThat(indexed1.getIndex(), is(0));
        assertThat(indexed1.getElement(), is("aaa"));

        final Indexed<String> indexed2 = it.next();
        assertThat(indexed2.getIndex(), is(1));
        assertThat(indexed2.getElement(), is("bbb"));

        final Indexed<String> indexed3 = it.next();
        assertThat(indexed3.getIndex(), is(2));
        assertThat(indexed3.getElement(), is("ccc"));

            'dependencies {'
        }

        @Override
        public String getEnd() {
            '}'
        }
    },
    API {
        @Override
        public String getBegin() {
            'api { dependencies {'
        }

        @Override
        public String getEnd() {
            '}}'
        }
    },
    SOURCES {
        @Override

    String toString() {
        return "[operation $name]"
    }

    Instant getEnd() {
        def instant = end.get()
        if (instant == null) {
            throw new IllegalStateException("Operation '$name' has not completed yet.")
        }
        return instant
    }

    Duration getDuration() {
        return getEnd() - start
    }

    void completed(Instant when) {

    }


    @Override
    public void encode ( NdrBuffer buf ) throws NdrException {
        int start = buf.getIndex();
        int alloc_hint_index = 0;

        buf.advance(16); /* momentarily skip header */
        if ( this.ptype == 0 ) { /* Request */
            alloc_hint_index = buf.getIndex();
            buf.enc_ndr_long(0); /* momentarily skip alloc hint */
            buf.enc_ndr_short(0); /* context id */

        call_id = buf.dec_ndr_long();
    }
    public void encode(NdrBuffer buf) throws NdrException {
        int start = buf.getIndex();
        int alloc_hint_index = 0;

        buf.advance(16); /* momentarily skip header */
        if (ptype == 0) { /* Request */
            alloc_hint_index = buf.getIndex();
            buf.enc_ndr_long(0); /* momentarily skip alloc hint */
            buf.enc_ndr_short(0); /* context id */

    NestedExceptionPlaceholder(Kind kind, int index) {
        this.kind = kind;
        this.index = index;
    }

    public Kind getKind() {
        return kind;
    }

    public int getIndex() {
        return index;
    }

    enum Kind {
        cause,
        suppressed
    }

 *     System.out.println(indexed.getIndex());
 *     System.out.println(indexed.getElement());
 * }
 * </pre>
 *
 * <pre>
 * import static org.codelibs.core.collection.IndexedIterator.*;
 * import static org.codelibs.core.io.LineIterator.*;
 *
 * BufferedReader reader = ...;
 * for (Indexed&lt;String%gt; indexed : indexed(iterable(reader))) {
 *     System.out.println(indexed.getIndex());

                return -1;
            } else if (!node1.isPriority() && node2.isPriority()) {
                return 1;
            }
            if (node1.getIndex() > node2.getIndex()) {
                return 1;
            } else if (node1.getIndex() < node2.getIndex()) {
                return -1;
            }
            return NodeComparator.INSTANCE.compare(node1, node2);
        }
    };