func (resp *Response) SetBodyStreamWriter(sw StreamWriter) {
	sr := NewStreamReader(sw)
	resp.SetBodyStream(sr, -1)
}
SetBodyStreamWriter registers the given sw for populating response body.

This function may be used in the following cases:

* if response body is too big (more than 10MB).
* if response body is streamed from slow external sources.
* if response body must be streamed to the client in chunks
(aka `http server push`).

See also SetBodyStream.
package fasthttp
import (
	"bufio"
	"bytes"
	"errors"
	"fmt"
	"io"
	"mime/multipart"
	"os"
	"sync"
)
type Request struct {
	noCopy noCopy
	Header RequestHeader
	body []byte
	w    requestBodyWriter
	bodyStream io.Reader
	uri      URI
	postArgs Args
	multipartForm         *multipart.Form
	multipartFormBoundary string
	parsedURI      bool
	parsedPostArgs bool
}
type Response struct {
	noCopy noCopy
	Header ResponseHeader
	body []byte
	w    responseBodyWriter
	bodyStream io.Reader
	SkipBody bool
}
func (req *Request) SetRequestURI(requestURI string) {
	req.Header.SetRequestURI(requestURI)
	req.parsedURI = false
}
func (req *Request) SetRequestURIBytes(requestURI []byte) {
	req.Header.SetRequestURIBytes(requestURI)
	req.parsedURI = false
}
func (req *Request) RequestURI() []byte {
	if req.parsedURI {
		requestURI := req.uri.RequestURI()
		req.SetRequestURIBytes(requestURI)
	}
	return req.Header.RequestURI()
}
func (resp *Response) StatusCode() int {
	return resp.Header.StatusCode()
}
func (resp *Response) SetStatusCode(statusCode int) {
	resp.Header.SetStatusCode(statusCode)
}
func (resp *Response) ConnectionClose() bool {
	return resp.Header.ConnectionClose()
}
func (resp *Response) SetConnectionClose() {
	resp.Header.SetConnectionClose()
}
func (req *Request) ConnectionClose() bool {
	return req.Header.ConnectionClose()
}
func (req *Request) SetConnectionClose() {
	req.Header.SetConnectionClose()
}
func (resp *Response) SendFile(path string) error {
	f, err := os.Open(path)
	if err != nil {
		return err
	}
	fileInfo, err := f.Stat()
	if err != nil {
		f.Close()
		return err
	}
	size64 := fileInfo.Size()
	size := int(size64)
	if int64(size) != size64 {
		size = -1
	}
	resp.Header.SetLastModified(fileInfo.ModTime())
	resp.SetBodyStream(f, size)
	return nil
}
func (req *Request) SetBodyStream(bodyStream io.Reader, bodySize int) {
	req.ResetBody()
	req.bodyStream = bodyStream
	req.Header.SetContentLength(bodySize)
}
func (resp *Response) SetBodyStream(bodyStream io.Reader, bodySize int) {
	resp.ResetBody()
	resp.bodyStream = bodyStream
	resp.Header.SetContentLength(bodySize)
}
func (req *Request) SetBodyStreamWriter(sw StreamWriter) {
	sr := NewStreamReader(sw)
	req.SetBodyStream(sr, -1)
}