class Protocol::HTTP::Body::Writable

A dynamic body which you can write to and read from.

def close(error = nil)

Stop generating output; cause the next call to write to fail with the given error. Does not prevent existing chunks from being read. In other words, this indicates both that no more data will be or should be written to the body. 
def close(error = nil)
	@error ||= error
	
	@queue.clear
	@queue.close
	
	super
end

def close_write(error = nil) 

def close_write(error = nil)
	@error ||= error
	@queue.close
end

def closed? 

def closed?
	@queue.closed?
end

def empty?

Has the producer called #finish and has the reader consumed the nil token? 
def empty?
	@queue.empty? && @queue.closed?
end

def initialize(length = nil, queue: Thread::Queue.new)

Parameters:
  • queue (Async::Queue) -- Specify a different queue implementation, e.g. `Async::LimitedQueue.new(8)` to enable back-pressure streaming.
  • length (Integer) -- The length of the response body if known. 
def initialize(length = nil, queue: Thread::Queue.new)
	@length = length
	@queue = queue
	@count = 0
	@error = nil
end

def inspect 

def inspect
	if @error
		"\#<#{self.class} #{@count} chunks written, #{status}, error=#{@error}>"
	else
		"\#<#{self.class} #{@count} chunks written, #{status}>"
	end
end

def length 

def length
	@length
end

def output

Create an output wrapper which can be used to write chunks to the body. 
def output
	output = Output.new(self)
	
	unless block_given?
		return output
	end
	
	begin
		yield output
	rescue => error
		raise error
	ensure
		output.close(error)
	end
end

def read

Read the next available chunk. 
def read
	if @error
		raise @error
	end
	
	# This operation may result in @error being set.
	chunk = @queue.pop
	
	if @error
		raise @error
	end
	
	return chunk
end

def ready? 

def ready?
	!@queue.empty? || @queue.closed?
end

def status 

def status
	if @queue.empty?
		if @queue.closed?
			"closed"
		else
			"waiting"
		end
	else
		if @queue.closed?
			"closing"
		else
			"ready"
		end
	end
end

def write(chunk)

Write a single chunk to the body. Signal completion by calling `#finish`. 
def write(chunk)
	if @queue.closed?
		raise(@error || Closed)
	end
	
	@queue.push(chunk)
	@count += 1
end