package http:client

Source

Body_Error :: enum int {
	None, 
	No_Length, 
	Invalid_Length, 
	Too_Long, 
	Scan_Failed, 
	Invalid_Chunk_Size, 
	Invalid_Trailer_Header, 
}

Body_Plain :: string

Body_Type :: union {
	string, 
	map[string]string, 
	Body_Error, 
}

Body_Url_Encoded :: map[string]string

Error :: union {
	net.Dial_Error, 
	net.Parse_Endpoint_Error, 
	net.Network_Error, 
	bufio.Scanner_Error, 
	Request_Error, 
	SSL_Error, 
}

Request :: struct {
	method:  http.Method,
	headers: http.Headers,
	cookies: [dynamic]http.Cookie,
	body:    bytes.Buffer,
}

Request_Error :: enum int {
	Ok, 
	Invalid_Response_HTTP_Version, 
	Invalid_Response_Method, 
	Invalid_Response_Header, 
	Invalid_Response_Cookie, 
}

Response :: struct {
	status:    http.Status,
	// headers and cookies should be considered read-only, after a response is returned.
	headers:   http.Headers,
	cookies:   [dynamic]http.Cookie,
	_socket:   Communication,
	_body:     bufio.Scanner,
	_body_err: Body_Error,
}

SSL_Error :: enum int {
	Ok, 
	Controlled_Shutdown, 
	Fatal_Shutdown, 
	SSL_Write_Failed, 
}

body_destroy :: proc(body: Body_Type, was_allocation: bool) {…}

get :: proc(target: string, allocator := context.allocator) -> (Response, Error) {…}

request :: proc(request: ^Request, target: string, allocator := context.allocator) -> (res: Response, err: Error) {…}

request_destroy :: proc(r: ^Request) {…}

request_init :: proc(r: ^Request, method: http.Method = http.Method.Get, allocator := context.allocator) {…}

response_body :: proc(res: ^Response, max_length: int = -1, allocator := context.allocator) -> (body: Body_Type, was_allocation: bool, err: Body_Error) {…}

response_destroy :: proc(res: ^Response, body: runtime.Maybe($T=Body_Type) = nil, was_allocation: bool = false) {…}

with_json :: proc(r: ^Request, v: any, opt: encoding_json.Marshal_Options = {}) -> encoding_json.Marshal_Error {…}