class Protocol::HTTP::Body::Stream

The input stream is an IO-like object which contains the raw HTTP POST data. When applicable, its external encoding must be “ASCII-8BIT” and it must be opened in binary mode, for Ruby 1.9 compatibility. The input stream must respond to gets, each, read and rewind.

def <<(buffer)

Write data to the stream using {write}. 
def <<(buffer)
	write(buffer)
end

def close(error = nil)

Close the input and output bodies. 
def close(error = nil)
	self.close_read(error)
	self.close_write(error)
	
	return nil
ensure
	@closed = true
end

def close_read(error = nil)

Close the input body. 
def close_read(error = nil)
	if input = @input
		@input = nil
		@closed_read = true
		@buffer = nil
		
		input.close(error)
	end
end

def close_write(error = nil)

Close the output body. 
def close_write(error = nil)
	if output = @output
		@output = nil
		
		output.close_write(error)
	end
end

def closed?

Whether the stream has been closed. 
def closed?
	@closed
end

def empty?

Whether there are any output chunks remaining? 
def empty?
	@output.empty?
end

def flush

This is currently a no-op.

Flush the output stream. 
def flush
end

def initialize(input = nil, output = Buffered.new) 

def initialize(input = nil, output = Buffered.new)
	@input = input
	@output = output
	
	raise ArgumentError, "Non-writable output!" unless output.respond_to?(:write)
	
	# Will hold remaining data in `#read`.
	@buffer = nil
	
	@closed = false
	@closed_read = false
end

def puts(*arguments, separator: NEWLINE)

@parameter separator [String] The line separator, defaults to `\n`.
@parameter arguments [Array(String)] The lines to write.

The current implementation buffers the lines and writes them in a single operation.

Write lines to the stream. 
def puts(*arguments, separator: NEWLINE)
	buffer = ::String.new
	
	arguments.each do |argument|
		buffer << argument << separator
	end
	
	write(buffer)
end

def read_next 

def read_next
	if @input
		return @input.read
	elsif @closed_read
		raise IOError, "Stream is not readable, input has been closed!"
	end
end

def write(buffer)

@returns [Integer] The number of bytes written.
@raises [IOError] If the stream is not writable.
@parameter buffer [String] The data to write.

Write data to the underlying stream. 
def write(buffer)
	if @output
		@output.write(buffer)
		return buffer.bytesize
	else
		raise IOError, "Stream is not writable, output has been closed!"
	end
end

def write_nonblock(buffer, exception: nil)

@returns [Integer] The number of bytes written.
@parameter exception [Boolean] Whether to raise an exception if the write would block, currently ignored.
@parameter buffer [String] The data to write.

Provided for compatibility with IO-like objects.

Write data to the stream using {write}. 
def write_nonblock(buffer, exception: nil)
	write(buffer)
end