Java Transport.END_OF_STREAM属性代码示例

/**
 * Pours the contents of {@code source} into {@code destinationTransportInput}, calling
 * the TransportInput many times if necessary.  If the TransportInput returns a {@link org.apache.qpid.proton.engine.TransportResult}
 * other than ok, data may remain in source.
 */
public static int pourAll(ByteBuffer source, TransportInput destinationTransportInput) throws TransportException
{
    int capacity = destinationTransportInput.capacity();
    if (capacity == Transport.END_OF_STREAM)
    {
        if (source.hasRemaining()) {
            throw new IllegalStateException("Destination has reached end of stream: " +
                                            destinationTransportInput);
        } else {
            return Transport.END_OF_STREAM;
        }
    }

    int total = source.remaining();

    while(source.hasRemaining() && destinationTransportInput.capacity() > 0)
    {
        pour(source, destinationTransportInput.tail());
        destinationTransportInput.process();
    }

    return total - source.remaining();
}
 

int recv(final byte[] bytes, int offset, int size)
{
    final int consumed;
    if (_data != null)
    {
        //TODO - should only be if no bytes left
        consumed = Math.min(size, _dataSize);

        System.arraycopy(_data, _offset, bytes, offset, consumed);
        _offset += consumed;
        _dataSize -= consumed;
    }
    else
    {
        _dataSize = consumed = 0;
    }

    return (_complete && consumed == 0) ? Transport.END_OF_STREAM : consumed;  //TODO - Implement
}
 

@Override
public int pending()
{
    if (isOutputInSaslMode() || _outputBuffer.position() != 0)
    {
        fillOutputBuffer();
        _head.limit(_outputBuffer.position());

        if (_head_closed && _outputBuffer.position() == 0)
        {
            return Transport.END_OF_STREAM;
        }
        else
        {
            return _outputBuffer.position();
        }
    }
    else
    {
        return _underlyingOutput.pending();
    }
}
 

@Override
public int pending()
{
    try {
        wrapOutput();
    } catch (SSLException e) {
        _logger.log(Level.WARNING, e.getMessage());
        _head_closed = true;
    }

    _head.limit(_outputBuffer.position());

    if (_head_closed && _outputBuffer.position() == 0) {
        return Transport.END_OF_STREAM;
    }

    return _outputBuffer.position();
}
 

@Override
public int capacity()
{
    if (_tail_closed) {
        return Transport.END_OF_STREAM;
    } else {
        if (_inputBuffer != null) {
            return _inputBuffer.remaining();
        } else {
            return _inputBufferSize;
        }
    }
}
 

@Override
public int position() {
    if (_tail_closed) {
        return Transport.END_OF_STREAM;
    }
    return (_inputBuffer == null) ? 0 : _inputBuffer.position();
}
 

@Override
public int capacity()
{
    if (_tail_closed) return Transport.END_OF_STREAM;
    if (isInputInSaslMode())
    {
        return _inputBuffer.remaining();
    }
    else
    {
        return _underlyingInput.capacity();
    }
}
 

@Override
public int position()
{
    if (_tail_closed) return Transport.END_OF_STREAM;
    if (isInputInSaslMode())
    {
        return _inputBuffer.position();
    }
    else
    {
        return _underlyingInput.position();
    }
}
 

private void reallyProcessInput() throws TransportException
{
    if(isInputInSaslMode())
    {
        if(_logger.isLoggable(Level.FINER))
        {
            _logger.log(Level.FINER, SaslImpl.this + " about to call input.");
        }

        _frameParser.input(_inputBuffer);
    }

    if(!isInputInSaslMode())
    {
        if(_logger.isLoggable(Level.FINER))
        {
            _logger.log(Level.FINER, SaslImpl.this + " about to call plain input");
        }

        if (_inputBuffer.hasRemaining())
        {
            int bytes = pourAll(_inputBuffer, _underlyingInput);
            if (bytes == Transport.END_OF_STREAM)
            {
                _tail_closed = true;
            }

            _underlyingInput.process();
        }
        else
        {
            _underlyingInput.process();
        }
    }
}
 

@Override
public int capacity()
{
    initTransportWrapperOnFirstIO();
    if (_initException == null) {
        return _transportWrapper.capacity();
    } else {
        return Transport.END_OF_STREAM;
    }
}
 

@Override
public int position()
{
    initTransportWrapperOnFirstIO();
    if (_initException == null) {
        return _transportWrapper.position();
    } else {
        return Transport.END_OF_STREAM;
    }
}
 

@Override
public int capacity()
{
    if (isDeterminationMade())
    {
        return _selectedTransportWrapper.capacity();
    }
    else
    {
        if (_tail_closed) { return Transport.END_OF_STREAM; }
        return _determinationBuffer.remaining();
    }
}
 

@Override
public int position()
{
    if (isDeterminationMade())
    {
        return _selectedTransportWrapper.position();
    }
    else
    {
        if (_tail_closed) { return Transport.END_OF_STREAM; }
        return _determinationBuffer.position();
    }
}
 

@Override
public int pending()
{
    if (_head_closed) { return Transport.END_OF_STREAM; }

    if (isDeterminationMade()) {
        return _selectedTransportWrapper.pending();
    } else {
        return 0;
    }

}
 

@Override
public int pending()
{
    if (_head_closed) {
        return Transport.END_OF_STREAM;
    }

    if(_outputBuffer == null)
    {
        init_buffers();
    }

    _output_done = _transportOutputWriter.writeInto(_outputBuffer);
    _head.limit(_outputBuffer.position());

    if (_outputBuffer.position() == 0 && _outputBuffer.capacity() > TransportImpl.BUFFER_RELEASE_THRESHOLD)
    {
        release_buffers();
    }

    if (_output_done && (_outputBuffer == null || _outputBuffer.position() == 0))
    {
        return Transport.END_OF_STREAM;
    }
    else
    {
        return _outputBuffer == null ? 0 : _outputBuffer.position();
    }
}