Replace hashmap with header_type array to store request and response headers (#23)

* Replace hashmap with header_type array to store request and response headers

* Remove unused import

* Explicit import

* Use optval for optional args default values

* remove set_default_headers

* migrate append_header procedure to http_response.f90

* Using move_alloc() to append response header

* Explicit imports

* Remove no longer used append_header

---------

Co-authored-by: milancurcic <caomaco@gmail.com>

Author: rajkumardongre

example/response_header.f90

@@ -1,31 +1,31 @@
 program response_header
+    ! This program demonstrates sending user-provided headers in a GET request
+    ! and iterating over the headers of the response sent back by the server.
     use stdlib_string_type, only: string_type, write(formatted)
     use http, only: response_type, request, header_type
+    
     implicit none
     type(response_type) :: response
-    type(string_type), allocatable :: header_keys(:)
-    type(header_type) :: req_header
+    type(header_type), allocatable :: header(:), req_header(:)
     character(:), allocatable :: val
     integer :: i = 0
 
-    ! setting request header
-    call req_header%set('h1', 'v1')
-    call req_header%set('h2', 'v2')
-    call req_header%set('h3', 'v3')
-    call req_header%set('h4', 'v4')
+    req_header = [ &
+      header_type('Another-One', 'Hello'), &
+      header_type('Set-Cookie', 'Theme-Light'), &
+      header_type('Set-Cookie', 'Auth-Token: 12345'), &
+      header_type('User-Agent', 'my user agent') &
+      ]
 
-    response = request(url='https://gorest.co.in/public/v2/todos/15726', header=req_header)
-    if(.not. response%ok) then
+    response = request(url='https://reqres.in/api/users/1', header=req_header)
+
+    if (.not. response%ok) then
         print *,'Error message : ', response%err_msg
     else
-        print *, '=========== Response header value by passing string_type ============'
-        header_keys = response%header%keys()
-        do i = 1, size(header_keys)
-            val = response%header%value(header_keys(i))
-            print *, header_keys(i), ': ', val
+        header = response%header
+        ! Iterate over response headers.
+        do i = 1, size(header)
+            print *, header(i)%key, ': ', header(i)%value
         end do
-        print *, '=========== Response header value by passing characters ============'
-        val = response%header%value('date')
-        print *, 'date', ' : ',val
     end if
-end program response_header
+end program response_header

example/simple_get.f90

@@ -1,5 +1,7 @@
 program simple_get
-    use http, only : response_type, request
+    ! This program demonstrates sending a simple GET request and printing the
+    ! status, length of the body, method, and the body of the response.
+    use http, only: response_type, request
     implicit none
     type(response_type) :: response
 
@@ -13,4 +15,4 @@ program simple_get
         print *, 'Response Content : ', response%content
     end if
 
-end program simple_get
+end program simple_get

fpm.toml

@@ -20,5 +20,4 @@ source-form = "free"
 
 [dependencies]
 fortran-curl = {git = "https://github.com/interkosmos/fortran-curl.git"}
-fhash = { git = "https://github.com/LKedward/fhash.git" }
 stdlib = "*"

src/http/http_client.f90

@@ -1,8 +1,14 @@
 module http_client
-    use iso_c_binding
-    use curl
-    use stdlib_string_type
-    use fhash, only: key => fhash_key
+    use iso_c_binding, only: c_associated, c_f_pointer, c_funloc, c_loc, &
+        c_null_char, c_null_ptr, c_ptr, c_size_t
+    use curl, only: c_f_str_ptr, curl_easy_cleanup, curl_easy_getinfo, &
+        curl_easy_init, curl_easy_perform, curl_easy_setopt, &
+        curl_easy_strerror, curl_slist_append, CURLE_OK, &
+        CURLINFO_RESPONSE_CODE, CURLOPT_CUSTOMREQUEST, CURLOPT_HEADERDATA, &
+        CURLOPT_HEADERFUNCTION, CURLOPT_HTTPHEADER, CURLOPT_URL, &
+        CURLOPT_WRITEDATA, CURLOPT_WRITEFUNCTION
+    use stdlib_optval, only: optval
+    use stdlib_string_type, only: string_type, to_lower, operator(==)
     use http_request, only: request_type
     use http_response, only: response_type
     use http_header, only : header_type
@@ -32,42 +38,35 @@ module http_client
     function new_request(url, method, header) result(response)
         character(len=*), intent(in) :: url
         integer, intent(in), optional :: method
-        type(header_type), intent(inout), optional :: header
-        type(header_type) :: default_header
+        type(header_type), intent(in), optional :: header(:)
         type(request_type) :: request
         type(response_type) :: response
         type(client_type) :: client
 
-        ! setting default HTTP method
-        if(present(method)) then 
-           request%method = method
-        else
-            request%method = 1
-        end if
+        ! Set default HTTP method.
+        request%method = optval(method, 1)
 
-        ! setting defautl request headers
+        ! Set default request headers.
+        request%header = [header_type('user-agent', 'fortran-http/1.0.0')]
         if(present(header)) then 
-            call set_default_headers(header)
-            request%header = header
-        else
-            call set_default_headers(default_header)
-            request%header = default_header
+            request%header = [header, request%header]
         end if
-        ! populate the request header_key array
-        call request%header%set_header_key()
+
         ! setting request url
         request%url = url
+        
         client = client_type(request=request)
-        response = client%client_get_response()
 
+        ! Populates the response 
+        response = client%client_get_response()
     end function new_request
+
     ! Constructor for client_type type.
     function new_client(request) result(client)
         type(request_type), intent(in) :: request
         type(client_type) :: client
 
         client%request = request
-
     end function new_client
 
     function client_get_response(this) result(response)
@@ -79,11 +78,10 @@ function client_get_response(this) result(response)
         curl_ptr = c_null_ptr
         header_list_ptr = c_null_ptr
 
-        ! logic for populating response using fortran-curl
         response%url = this%request%url
 
         ! prepare headers for curl
-        call prepare_request_header_ptr(header_list_ptr, this%request)
+        call prepare_request_header_ptr(header_list_ptr, this%request%header)
 
         curl_ptr = curl_easy_init()
 
@@ -94,20 +92,28 @@ & function failed. This can occur due to insufficient memory available in the sy
             & Additionally, if libcurl is not installed or configured properly on the system"
             return
         end if
+
         ! setting request URL
         rc = curl_easy_setopt(curl_ptr, CURLOPT_URL, this%request%url // c_null_char)
+
         ! setting request method
         rc = client_set_method(curl_ptr, this%request%method, response)
+
         ! setting request header
         rc = curl_easy_setopt(curl_ptr, CURLOPT_HTTPHEADER, header_list_ptr);
+
         ! setting callback for writing received data
         rc = curl_easy_setopt(curl_ptr, CURLOPT_WRITEFUNCTION, c_funloc(client_response_callback))
+
         ! setting response content pointer to write callback
         rc = curl_easy_setopt(curl_ptr, CURLOPT_WRITEDATA, c_loc(response))
+
         ! setting callback for writing received headers
         rc = curl_easy_setopt(curl_ptr, CURLOPT_HEADERFUNCTION, c_funloc(client_header_callback))
+
         ! setting response header pointer to write callback
         rc = curl_easy_setopt(curl_ptr, CURLOPT_HEADERDATA, c_loc(response))
+
         ! Send request.
         rc = curl_easy_perform(curl_ptr)
 
@@ -119,35 +125,24 @@ & function failed. This can occur due to insufficient memory available in the sy
         ! setting response status_code
         rc = curl_easy_getinfo(curl_ptr, CURLINFO_RESPONSE_CODE, response%status_code)  
 
-        ! populate the response header_key array
-        call  response%header%set_header_key()
-        
         call curl_easy_cleanup(curl_ptr)
 
     end function client_get_response
 
-    subroutine prepare_request_header_ptr(header_list_ptr, request)
-        class(request_type), intent(in) :: request
+    subroutine prepare_request_header_ptr(header_list_ptr, req_headers)
         type(c_ptr), intent(out) :: header_list_ptr
-        type(string_type), allocatable :: req_headers(:)
+        type(header_type), allocatable, intent(in) :: req_headers(:)
         character(:), allocatable :: h_key, h_val, final_header_string
         integer :: i
 
-        req_headers = request%header%keys()
         do i = 1, size(req_headers)
-            h_key = char(req_headers(i))
-            h_val = request%header%value(req_headers(i))
-
+            h_key = req_headers(i)%key
+            h_val = req_headers(i)%value
             final_header_string = h_key // ':' // h_val // c_null_char
             header_list_ptr = curl_slist_append(header_list_ptr, final_header_string)
         end do
     end subroutine prepare_request_header_ptr
 
-    subroutine set_default_headers(header)
-        type(header_type), intent(inout) :: header
-        call header%set('User-Agent', 'fortran-http/1.0.0')
-    end subroutine set_default_headers
-
     function client_set_method(curl_ptr, method, response) result(status)
         type(c_ptr), intent(out) :: curl_ptr
         integer, intent(in) :: method
@@ -203,6 +198,7 @@ function client_response_callback(ptr, size, nmemb, client_data) bind(c)
         response%content = response%content // buf
         deallocate (buf)
         response%content_length = response%content_length + nmemb
+        
         ! Return number of received bytes.
         client_response_callback = nmemb
 
@@ -230,20 +226,23 @@ function client_header_callback(ptr, size, nmemb, client_data) bind(c)
         ! Convert C pointer to Fortran allocatable character.
         call c_f_str_ptr(ptr, buf, nmemb)
         if (.not. allocated(buf)) return
+        
         ! Parsing Header, and storing in hashmap
         i = index(buf, ':')
         if(i /= 0 .and. len(buf) > 2) then
             h_key = trim(buf(:i-1))
             h_value = buf(i+2 : )
             h_value = h_value( : len(h_value)-2)
             if(len(h_value) > 0 .and. len(h_key) > 0) then
-                call response%header%set(h_key, h_value)
+                call response%append_header(h_key, h_value)
+                ! response%header = [response%header, header_type(h_key, h_value)]
             end if
         end if
         deallocate(buf)
+        
         ! Return number of received bytes.
         client_header_callback = nmemb
 
     end function client_header_callback
-      
+
 end module http_client

src/http/http_header.f90

@@ -1,76 +1,9 @@
 module http_header
     use iso_c_binding
-    use fhash, only: fhash_tbl_t, key => fhash_key, fhash_iter_t, fhash_key_t
-    use stdlib_string_type
-    ! use curl
     implicit none
     private
     public :: header_type
     type :: header_type
-        type(fhash_tbl_t), private :: header
-        type(string_type), private, allocatable :: header_key(:)
-        integer :: header_count = 0
-    contains
-        procedure :: set_header_key
-        procedure :: keys => get_header_keys
-        procedure :: header_string_type_key
-        procedure :: header_char_key
-        generic :: value => header_string_type_key, header_char_key
-        procedure :: set => update_header
+        character(:), allocatable :: key, value
     end type header_type
-contains
-    subroutine update_header(this, h_key, h_val)
-        class(header_type), intent(inout) :: this
-        character(*), intent(in) :: h_key, h_val
-        if(len_trim(h_key) > 0 .and.  len_trim(h_val) > 0) then
-            call this%header%set(key(h_key), value=h_val)
-            this%header_count = this%header_count + 1
-        end if
-    end subroutine update_header
-
-    subroutine set_header_key(this)
-        class(header_type), intent(inout) :: this
-        type(fhash_iter_t) :: iter
-        class(fhash_key_t), allocatable :: ikey
-        class(*), allocatable :: idata
-        character(:), allocatable :: val
-        integer :: i
-        i = 1
-        allocate(this%header_key(this%header_count))
-        iter = fhash_iter_t(this%header)
-        do while(iter%next(ikey,idata) .and. i <= this%header_count)
-            this%header_key(i) = string_type(trim(ikey%to_string()))
-            i = i + 1
-        end do
-    end subroutine set_header_key
-
-    function get_header_keys(this) 
-        class(header_type), intent(in) :: this
-        type(string_type), allocatable :: get_header_keys(:)
-        get_header_keys = this%header_key
-    end function get_header_keys
-
-    function header_string_type_key(this, h_key) result(header_value)
-        class(header_type) :: this
-        type(string_type) :: h_key
-        character(:), allocatable :: header_value
-        if(len(h_key) > 0) then
-            call this%header%get(key(char(h_key)),header_value)
-        else
-            header_value = ''
-        end if
-    end function header_string_type_key
-
-    function header_char_key(this, h_key) result(header_value)
-        class(header_type) :: this
-        character(*) :: h_key
-        character(:), allocatable :: header_value
-        if(len(h_key) > 0) then
-            call this%header%get(key(h_key),header_value)
-        else
-            header_value = ''
-        end if
-    end function header_char_key
-
-
 end module http_header

src/http/http_request.f90

@@ -1,5 +1,4 @@
 module http_request
-    use, intrinsic :: iso_c_binding
     use http_header, only : header_type
     implicit none
 
@@ -19,7 +18,7 @@ module http_request
     type :: request_type
         character(len=:), allocatable :: url
         integer :: method
-        type(header_type) :: header
+        type(header_type), allocatable :: header(:)
     end type request_type
 
 end module http_request

src/http/http_response.f90

@@ -12,7 +12,30 @@ module http_response
         integer :: status_code = 0
         integer(kind=int64) :: content_length = 0
         logical :: ok = .true.
-        type(header_type) :: header
+        type(header_type), allocatable :: header(:)
+    contains
+        procedure :: append_header
     end type response_type
 
+contains
+    subroutine append_header(this, key, value)
+        class(response_type), intent(inout) :: this
+        character(*), intent(in) :: key, value
+        type(header_type), allocatable :: temp(:)
+        integer :: n
+    
+        if (allocated(this%header)) then
+            n = size(this%header)
+            allocate(temp(n+1))
+            temp(1:n) = this%header
+            temp(n+1) = header_type(key, value)
+            call move_alloc(temp, this%header)
+        else
+            allocate(this%header(1))
+            this%header(1) = header_type(key, value)
+        end if
+    
+    end subroutine append_header
+  
+
 end module http_response