refactor HeaderValue into ByteString

yskopets · yskopets · commit 57a9a5f5d6ee · 2020-08-25T00:59:58.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -16,6 +16,7 @@ wee_alloc = "0.4"
 [dev-dependencies]
 version-sync = "0.9"
 chrono = "0.4"
+bstr = "0.2"
 
 [profile.release]
 lto = true
diff --git a/src/hostcalls.rs b/src/hostcalls.rs
@@ -112,18 +112,16 @@ extern "C" {
 }
 
 /// Returns configuration, e.g. VM configuration, extension configuration, etc.
-pub fn get_configuration() -> Result<Option<Bytes>> {
+pub fn get_configuration() -> Result<Option<ByteString>> {
     let mut return_data: *mut u8 = null_mut();
     let mut return_size: usize = 0;
     unsafe {
         match proxy_get_configuration(&mut return_data, &mut return_size) {
             Status::Ok => {
                 if !return_data.is_null() {
-                    Ok(Some(Vec::from_raw_parts(
-                        return_data,
-                        return_size,
-                        return_size,
-                    )))
+                    Ok(Vec::from_raw_parts(return_data, return_size, return_size))
+                        .map(ByteString::from)
+                        .map(Option::from)
                 } else {
                     Ok(None)
                 }
@@ -144,7 +142,11 @@ extern "C" {
 }
 
 /// Returns content from a given buffer.
-pub fn get_buffer(buffer_type: BufferType, start: usize, max_size: usize) -> Result<Option<Bytes>> {
+pub fn get_buffer(
+    buffer_type: BufferType,
+    start: usize,
+    max_size: usize,
+) -> Result<Option<ByteString>> {
     let mut return_data: *mut u8 = null_mut();
     let mut return_size: usize = 0;
     unsafe {
@@ -157,11 +159,9 @@ pub fn get_buffer(buffer_type: BufferType, start: usize, max_size: usize) -> Res
         ) {
             Status::Ok => {
                 if !return_data.is_null() {
-                    Ok(Some(Vec::from_raw_parts(
-                        return_data,
-                        return_size,
-                        return_size,
-                    )))
+                    Ok(Vec::from_raw_parts(return_data, return_size, return_size))
+                        .map(ByteString::from)
+                        .map(Option::from)
                 } else {
                     Ok(None)
                 }
@@ -181,7 +181,7 @@ extern "C" {
 }
 
 /// Returns all key-value pairs from a given map.
-pub fn get_map(map_type: MapType) -> Result<Vec<(String, HeaderValue)>> {
+pub fn get_map(map_type: MapType) -> Result<Vec<(ByteString, ByteString)>> {
     unsafe {
         let mut return_data: *mut u8 = null_mut();
         let mut return_size: usize = 0;
@@ -264,7 +264,7 @@ extern "C" {
 /// # Ok(())
 /// # }
 /// ```
-pub fn get_map_value<K>(map_type: MapType, key: K) -> Result<Option<HeaderValue>>
+pub fn get_map_value<K>(map_type: MapType, key: K) -> Result<Option<ByteString>>
 where
     K: AsRef<str>,
 {
@@ -281,7 +281,7 @@ where
             Status::Ok => {
                 if !return_data.is_null() {
                     Ok(Vec::from_raw_parts(return_data, return_size, return_size))
-                        .map(HeaderValue::from)
+                        .map(ByteString::from)
                         .map(Option::from)
                 } else {
                     Ok(None)
@@ -420,7 +420,7 @@ extern "C" {
 /// # Ok(())
 /// # }
 /// ```
-pub fn get_property<P>(path: &[P]) -> Result<Option<Bytes>>
+pub fn get_property<P>(path: &[P]) -> Result<Option<ByteString>>
 where
     P: AsRef<str>,
 {
@@ -436,11 +436,9 @@ where
         ) {
             Status::Ok => {
                 if !return_data.is_null() {
-                    Ok(Some(Vec::from_raw_parts(
-                        return_data,
-                        return_size,
-                        return_size,
-                    )))
+                    Ok(Vec::from_raw_parts(return_data, return_size, return_size))
+                        .map(ByteString::from)
+                        .map(Option::from)
                 } else {
                     Ok(None)
                 }
@@ -518,7 +516,7 @@ extern "C" {
 /// # Ok(())
 /// # }
 /// ```
-pub fn get_shared_data<K>(key: K) -> Result<(Option<Bytes>, Option<u32>)>
+pub fn get_shared_data<K>(key: K) -> Result<(Option<ByteString>, Option<u32>)>
 where
     K: AsRef<str>,
 {
@@ -540,7 +538,8 @@ where
                 };
                 if !return_data.is_null() {
                     Ok((
-                        Some(Vec::from_raw_parts(return_data, return_size, return_size)),
+                        Some(Vec::from_raw_parts(return_data, return_size, return_size))
+                            .map(ByteString::from),
                         cas,
                     ))
                 } else {
@@ -654,18 +653,16 @@ extern "C" {
 }
 
 /// Returns data from the end of a given queue.
-pub fn dequeue_shared_queue(queue_id: u32) -> Result<Option<Bytes>> {
+pub fn dequeue_shared_queue(queue_id: u32) -> Result<Option<ByteString>> {
     let mut return_data: *mut u8 = null_mut();
     let mut return_size: usize = 0;
     unsafe {
         match proxy_dequeue_shared_queue(queue_id, &mut return_data, &mut return_size) {
             Status::Ok => {
                 if !return_data.is_null() {
-                    Ok(Some(Vec::from_raw_parts(
-                        return_data,
-                        return_size,
-                        return_size,
-                    )))
+                    Ok(Vec::from_raw_parts(return_data, return_size, return_size))
+                        .map(ByteString::from)
+                        .map(Option::from)
                 } else {
                     Ok(None)
                 }
@@ -925,10 +922,10 @@ pub fn done() -> Result<()> {
 
 mod utils {
     use crate::error::Result;
-    use crate::types::{Bytes, HeaderValue};
+    use crate::types::ByteString;
     use std::convert::TryFrom;
 
-    pub(super) fn serialize_property_path<P>(path: &[P]) -> Bytes
+    pub(super) fn serialize_property_path<P>(path: &[P]) -> Vec<u8>
     where
         P: AsRef<str>,
     {
@@ -939,7 +936,7 @@ mod utils {
         for part in path {
             size += part.as_ref().len() + 1;
         }
-        let mut bytes: Bytes = Vec::with_capacity(size);
+        let mut bytes: Vec<u8> = Vec::with_capacity(size);
         for part in path {
             bytes.extend_from_slice(part.as_ref().as_bytes());
             bytes.push(0);
@@ -948,7 +945,7 @@ mod utils {
         bytes
     }
 
-    pub(super) fn serialize_map<K, V>(map: &[(K, V)]) -> Bytes
+    pub(super) fn serialize_map<K, V>(map: &[(K, V)]) -> Vec<u8>
     where
         K: AsRef<str>,
         V: AsRef<[u8]>,
@@ -957,7 +954,7 @@ mod utils {
         for (name, value) in map {
             size += name.as_ref().len() + value.as_ref().len() + 10;
         }
-        let mut bytes: Bytes = Vec::with_capacity(size);
+        let mut bytes: Vec<u8> = Vec::with_capacity(size);
         bytes.extend_from_slice(&map.len().to_le_bytes());
         for (name, value) in map {
             bytes.extend_from_slice(&name.as_ref().len().to_le_bytes());
@@ -972,7 +969,7 @@ mod utils {
         bytes
     }
 
-    pub(super) fn deserialize_map(bytes: &[u8]) -> Result<Vec<(String, HeaderValue)>> {
+    pub(super) fn deserialize_map(bytes: &[u8]) -> Result<Vec<(ByteString, ByteString)>> {
         let mut map = Vec::new();
         if bytes.is_empty() {
             return Ok(map);
@@ -987,7 +984,7 @@ mod utils {
             let size = u32::from_le_bytes(<[u8; 4]>::try_from(&bytes[s + 4..s + 8])?) as usize;
             let value = bytes[p..p + size].to_vec();
             p += size + 1;
-            map.push((String::from_utf8(key)?, value.into()));
+            map.push((key.into(), value.into()));
         }
         Ok(map)
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -20,6 +20,7 @@ pub mod traits;
 pub mod types;
 
 mod allocator;
+mod bytestring;
 mod dispatcher;
 mod logger;
 
diff --git a/src/traits.rs b/src/traits.rs
@@ -23,15 +23,15 @@ pub trait Context {
         hostcalls::get_current_time().unwrap()
     }
 
-    fn get_property(&self, path: Vec<&str>) -> Option<Bytes> {
+    fn get_property(&self, path: Vec<&str>) -> Option<ByteString> {
         hostcalls::get_property(&path).unwrap()
     }
 
     fn set_property(&self, path: Vec<&str>, value: Option<&[u8]>) {
         hostcalls::set_property(&path, value).unwrap()
     }
 
-    fn get_shared_data(&self, key: &str) -> (Option<Bytes>, Option<u32>) {
+    fn get_shared_data(&self, key: &str) -> (Option<ByteString>, Option<u32>) {
         hostcalls::get_shared_data(key).unwrap()
     }
 
@@ -47,7 +47,7 @@ pub trait Context {
         hostcalls::resolve_shared_queue(vm_id, name).unwrap()
     }
 
-    fn dequeue_shared_queue(&self, queue_id: u32) -> Result<Option<Bytes>> {
+    fn dequeue_shared_queue(&self, queue_id: u32) -> Result<Option<ByteString>> {
         hostcalls::dequeue_shared_queue(queue_id)
     }
 
@@ -75,15 +75,15 @@ pub trait Context {
     ) {
     }
 
-    fn get_http_call_response_headers(&self) -> Vec<(String, HeaderValue)> {
+    fn get_http_call_response_headers(&self) -> Vec<(ByteString, ByteString)> {
         hostcalls::get_map(MapType::HttpCallResponseHeaders).unwrap()
     }
 
-    fn get_http_call_response_body(&self, start: usize, max_size: usize) -> Option<Bytes> {
+    fn get_http_call_response_body(&self, start: usize, max_size: usize) -> Option<ByteString> {
         hostcalls::get_buffer(BufferType::HttpCallResponseBody, start, max_size).unwrap()
     }
 
-    fn get_http_call_response_trailers(&self) -> Vec<(String, HeaderValue)> {
+    fn get_http_call_response_trailers(&self) -> Vec<(ByteString, ByteString)> {
         hostcalls::get_map(MapType::HttpCallResponseTrailers).unwrap()
     }
 
@@ -111,7 +111,7 @@ pub trait RootContext: Context {
         true
     }
 
-    fn get_configuration(&self) -> Option<Bytes> {
+    fn get_configuration(&self) -> Option<ByteString> {
         hostcalls::get_configuration().unwrap()
     }
 
@@ -141,7 +141,7 @@ pub trait StreamContext: Context {
         Action::Continue
     }
 
-    fn get_downstream_data(&self, start: usize, max_size: usize) -> Option<Bytes> {
+    fn get_downstream_data(&self, start: usize, max_size: usize) -> Option<ByteString> {
         hostcalls::get_buffer(BufferType::DownstreamData, start, max_size).unwrap()
     }
 
@@ -151,7 +151,7 @@ pub trait StreamContext: Context {
         Action::Continue
     }
 
-    fn get_upstream_data(&self, start: usize, max_size: usize) -> Option<Bytes> {
+    fn get_upstream_data(&self, start: usize, max_size: usize) -> Option<ByteString> {
         hostcalls::get_buffer(BufferType::UpstreamData, start, max_size).unwrap()
     }
 
@@ -165,15 +165,15 @@ pub trait HttpContext: Context {
         Action::Continue
     }
 
-    fn get_http_request_headers(&self) -> Vec<(String, HeaderValue)> {
+    fn get_http_request_headers(&self) -> Vec<(ByteString, ByteString)> {
         hostcalls::get_map(MapType::HttpRequestHeaders).unwrap()
     }
 
     fn set_http_request_headers(&self, headers: Vec<(&str, &str)>) {
         hostcalls::set_map(MapType::HttpRequestHeaders, &headers).unwrap()
     }
 
-    fn get_http_request_header(&self, name: &str) -> Option<HeaderValue> {
+    fn get_http_request_header(&self, name: &str) -> Option<ByteString> {
         hostcalls::get_map_value(MapType::HttpRequestHeaders, &name).unwrap()
     }
 
@@ -189,23 +189,23 @@ pub trait HttpContext: Context {
         Action::Continue
     }
 
-    fn get_http_request_body(&self, start: usize, max_size: usize) -> Option<Bytes> {
+    fn get_http_request_body(&self, start: usize, max_size: usize) -> Option<ByteString> {
         hostcalls::get_buffer(BufferType::HttpRequestBody, start, max_size).unwrap()
     }
 
     fn on_http_request_trailers(&mut self, _num_trailers: usize) -> Action {
         Action::Continue
     }
 
-    fn get_http_request_trailers(&self) -> Vec<(String, HeaderValue)> {
+    fn get_http_request_trailers(&self) -> Vec<(ByteString, ByteString)> {
         hostcalls::get_map(MapType::HttpRequestTrailers).unwrap()
     }
 
     fn set_http_request_trailers(&self, trailers: Vec<(&str, &str)>) {
         hostcalls::set_map(MapType::HttpRequestTrailers, &trailers).unwrap()
     }
 
-    fn get_http_request_trailer(&self, name: &str) -> Option<HeaderValue> {
+    fn get_http_request_trailer(&self, name: &str) -> Option<ByteString> {
         hostcalls::get_map_value(MapType::HttpRequestTrailers, &name).unwrap()
     }
 
@@ -225,15 +225,15 @@ pub trait HttpContext: Context {
         Action::Continue
     }
 
-    fn get_http_response_headers(&self) -> Vec<(String, HeaderValue)> {
+    fn get_http_response_headers(&self) -> Vec<(ByteString, ByteString)> {
         hostcalls::get_map(MapType::HttpResponseHeaders).unwrap()
     }
 
     fn set_http_response_headers(&self, headers: Vec<(&str, &str)>) {
         hostcalls::set_map(MapType::HttpResponseHeaders, &headers).unwrap()
     }
 
-    fn get_http_response_header(&self, name: &str) -> Option<HeaderValue> {
+    fn get_http_response_header(&self, name: &str) -> Option<ByteString> {
         hostcalls::get_map_value(MapType::HttpResponseHeaders, &name).unwrap()
     }
 
@@ -249,23 +249,23 @@ pub trait HttpContext: Context {
         Action::Continue
     }
 
-    fn get_http_response_body(&self, start: usize, max_size: usize) -> Option<Bytes> {
+    fn get_http_response_body(&self, start: usize, max_size: usize) -> Option<ByteString> {
         hostcalls::get_buffer(BufferType::HttpResponseBody, start, max_size).unwrap()
     }
 
     fn on_http_response_trailers(&mut self, _num_trailers: usize) -> Action {
         Action::Continue
     }
 
-    fn get_http_response_trailers(&self) -> Vec<(String, HeaderValue)> {
+    fn get_http_response_trailers(&self) -> Vec<(ByteString, ByteString)> {
         hostcalls::get_map(MapType::HttpResponseTrailers).unwrap()
     }
 
     fn set_http_response_trailers(&self, headers: Vec<(&str, &str)>) {
         hostcalls::set_map(MapType::HttpResponseTrailers, &headers).unwrap()
     }
 
-    fn get_http_response_trailer(&self, name: &str) -> Option<HeaderValue> {
+    fn get_http_response_trailer(&self, name: &str) -> Option<ByteString> {
         hostcalls::get_map_value(MapType::HttpResponseTrailers, &name).unwrap()
     }
 
diff --git a/src/types.rs b/src/types.rs

Original file line number	Diff line number	Diff line change
`@@ -23,15 +23,15 @@ pub trait Context {`
`23`	`23`	`hostcalls::get_current_time().unwrap()`
`24`	`24`	`}`
`25`	`25`
`26`		`- fn get_property(&self, path: Vec<&str>) -> Option<Bytes> {`
	`26`	`+ fn get_property(&self, path: Vec<&str>) -> Option<ByteString> {`
`27`	`27`	`hostcalls::get_property(&path).unwrap()`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`fn set_property(&self, path: Vec<&str>, value: Option<&[u8]>) {`
`31`	`31`	`hostcalls::set_property(&path, value).unwrap()`
`32`	`32`	`}`
`33`	`33`
`34`		`- fn get_shared_data(&self, key: &str) -> (Option<Bytes>, Option<u32>) {`
	`34`	`+ fn get_shared_data(&self, key: &str) -> (Option<ByteString>, Option<u32>) {`
`35`	`35`	`hostcalls::get_shared_data(key).unwrap()`
`36`	`36`	`}`
`37`	`37`
`@@ -47,7 +47,7 @@ pub trait Context {`
`47`	`47`	`hostcalls::resolve_shared_queue(vm_id, name).unwrap()`
`48`	`48`	`}`
`49`	`49`
`50`		`- fn dequeue_shared_queue(&self, queue_id: u32) -> Result<Option<Bytes>> {`
	`50`	`+ fn dequeue_shared_queue(&self, queue_id: u32) -> Result<Option<ByteString>> {`
`51`	`51`	`hostcalls::dequeue_shared_queue(queue_id)`
`52`	`52`	`}`
`53`	`53`
`@@ -75,15 +75,15 @@ pub trait Context {`
`75`	`75`	`) {`
`76`	`76`	`}`
`77`	`77`
`78`		`- fn get_http_call_response_headers(&self) -> Vec<(String, HeaderValue)> {`
	`78`	`+ fn get_http_call_response_headers(&self) -> Vec<(ByteString, ByteString)> {`
`79`	`79`	`hostcalls::get_map(MapType::HttpCallResponseHeaders).unwrap()`
`80`	`80`	`}`
`81`	`81`
`82`		`- fn get_http_call_response_body(&self, start: usize, max_size: usize) -> Option<Bytes> {`
	`82`	`+ fn get_http_call_response_body(&self, start: usize, max_size: usize) -> Option<ByteString> {`
`83`	`83`	`hostcalls::get_buffer(BufferType::HttpCallResponseBody, start, max_size).unwrap()`
`84`	`84`	`}`
`85`	`85`
`86`		`- fn get_http_call_response_trailers(&self) -> Vec<(String, HeaderValue)> {`
	`86`	`+ fn get_http_call_response_trailers(&self) -> Vec<(ByteString, ByteString)> {`
`87`	`87`	`hostcalls::get_map(MapType::HttpCallResponseTrailers).unwrap()`
`88`	`88`	`}`
`89`	`89`
`@@ -111,7 +111,7 @@ pub trait RootContext: Context {`
`111`	`111`	`true`
`112`	`112`	`}`
`113`	`113`
`114`		`- fn get_configuration(&self) -> Option<Bytes> {`
	`114`	`+ fn get_configuration(&self) -> Option<ByteString> {`
`115`	`115`	`hostcalls::get_configuration().unwrap()`
`116`	`116`	`}`
`117`	`117`
`@@ -141,7 +141,7 @@ pub trait StreamContext: Context {`
`141`	`141`	`Action::Continue`
`142`	`142`	`}`
`143`	`143`
`144`		`- fn get_downstream_data(&self, start: usize, max_size: usize) -> Option<Bytes> {`
	`144`	`+ fn get_downstream_data(&self, start: usize, max_size: usize) -> Option<ByteString> {`
`145`	`145`	`hostcalls::get_buffer(BufferType::DownstreamData, start, max_size).unwrap()`
`146`	`146`	`}`
`147`	`147`
`@@ -151,7 +151,7 @@ pub trait StreamContext: Context {`
`151`	`151`	`Action::Continue`
`152`	`152`	`}`
`153`	`153`
`154`		`- fn get_upstream_data(&self, start: usize, max_size: usize) -> Option<Bytes> {`
	`154`	`+ fn get_upstream_data(&self, start: usize, max_size: usize) -> Option<ByteString> {`
`155`	`155`	`hostcalls::get_buffer(BufferType::UpstreamData, start, max_size).unwrap()`
`156`	`156`	`}`
`157`	`157`
`@@ -165,15 +165,15 @@ pub trait HttpContext: Context {`
`165`	`165`	`Action::Continue`
`166`	`166`	`}`
`167`	`167`
`168`		`- fn get_http_request_headers(&self) -> Vec<(String, HeaderValue)> {`
	`168`	`+ fn get_http_request_headers(&self) -> Vec<(ByteString, ByteString)> {`
`169`	`169`	`hostcalls::get_map(MapType::HttpRequestHeaders).unwrap()`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`fn set_http_request_headers(&self, headers: Vec<(&str, &str)>) {`
`173`	`173`	`hostcalls::set_map(MapType::HttpRequestHeaders, &headers).unwrap()`
`174`	`174`	`}`
`175`	`175`
`176`		`- fn get_http_request_header(&self, name: &str) -> Option<HeaderValue> {`
	`176`	`+ fn get_http_request_header(&self, name: &str) -> Option<ByteString> {`
`177`	`177`	`hostcalls::get_map_value(MapType::HttpRequestHeaders, &name).unwrap()`
`178`	`178`	`}`
`179`	`179`
`@@ -189,23 +189,23 @@ pub trait HttpContext: Context {`
`189`	`189`	`Action::Continue`
`190`	`190`	`}`
`191`	`191`
`192`		`- fn get_http_request_body(&self, start: usize, max_size: usize) -> Option<Bytes> {`
	`192`	`+ fn get_http_request_body(&self, start: usize, max_size: usize) -> Option<ByteString> {`
`193`	`193`	`hostcalls::get_buffer(BufferType::HttpRequestBody, start, max_size).unwrap()`
`194`	`194`	`}`
`195`	`195`
`196`	`196`	`fn on_http_request_trailers(&mut self, _num_trailers: usize) -> Action {`
`197`	`197`	`Action::Continue`
`198`	`198`	`}`
`199`	`199`
`200`		`- fn get_http_request_trailers(&self) -> Vec<(String, HeaderValue)> {`
	`200`	`+ fn get_http_request_trailers(&self) -> Vec<(ByteString, ByteString)> {`
`201`	`201`	`hostcalls::get_map(MapType::HttpRequestTrailers).unwrap()`
`202`	`202`	`}`
`203`	`203`
`204`	`204`	`fn set_http_request_trailers(&self, trailers: Vec<(&str, &str)>) {`
`205`	`205`	`hostcalls::set_map(MapType::HttpRequestTrailers, &trailers).unwrap()`
`206`	`206`	`}`
`207`	`207`
`208`		`- fn get_http_request_trailer(&self, name: &str) -> Option<HeaderValue> {`
	`208`	`+ fn get_http_request_trailer(&self, name: &str) -> Option<ByteString> {`
`209`	`209`	`hostcalls::get_map_value(MapType::HttpRequestTrailers, &name).unwrap()`
`210`	`210`	`}`
`211`	`211`
`@@ -225,15 +225,15 @@ pub trait HttpContext: Context {`
`225`	`225`	`Action::Continue`
`226`	`226`	`}`
`227`	`227`
`228`		`- fn get_http_response_headers(&self) -> Vec<(String, HeaderValue)> {`
	`228`	`+ fn get_http_response_headers(&self) -> Vec<(ByteString, ByteString)> {`
`229`	`229`	`hostcalls::get_map(MapType::HttpResponseHeaders).unwrap()`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`fn set_http_response_headers(&self, headers: Vec<(&str, &str)>) {`
`233`	`233`	`hostcalls::set_map(MapType::HttpResponseHeaders, &headers).unwrap()`
`234`	`234`	`}`
`235`	`235`
`236`		`- fn get_http_response_header(&self, name: &str) -> Option<HeaderValue> {`
	`236`	`+ fn get_http_response_header(&self, name: &str) -> Option<ByteString> {`
`237`	`237`	`hostcalls::get_map_value(MapType::HttpResponseHeaders, &name).unwrap()`
`238`	`238`	`}`
`239`	`239`
`@@ -249,23 +249,23 @@ pub trait HttpContext: Context {`
`249`	`249`	`Action::Continue`
`250`	`250`	`}`
`251`	`251`
`252`		`- fn get_http_response_body(&self, start: usize, max_size: usize) -> Option<Bytes> {`
	`252`	`+ fn get_http_response_body(&self, start: usize, max_size: usize) -> Option<ByteString> {`
`253`	`253`	`hostcalls::get_buffer(BufferType::HttpResponseBody, start, max_size).unwrap()`
`254`	`254`	`}`
`255`	`255`
`256`	`256`	`fn on_http_response_trailers(&mut self, _num_trailers: usize) -> Action {`
`257`	`257`	`Action::Continue`
`258`	`258`	`}`
`259`	`259`
`260`		`- fn get_http_response_trailers(&self) -> Vec<(String, HeaderValue)> {`
	`260`	`+ fn get_http_response_trailers(&self) -> Vec<(ByteString, ByteString)> {`
`261`	`261`	`hostcalls::get_map(MapType::HttpResponseTrailers).unwrap()`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`fn set_http_response_trailers(&self, headers: Vec<(&str, &str)>) {`
`265`	`265`	`hostcalls::set_map(MapType::HttpResponseTrailers, &headers).unwrap()`
`266`	`266`	`}`
`267`	`267`
`268`		`- fn get_http_response_trailer(&self, name: &str) -> Option<HeaderValue> {`
	`268`	`+ fn get_http_response_trailer(&self, name: &str) -> Option<ByteString> {`
`269`	`269`	`hostcalls::get_map_value(MapType::HttpResponseTrailers, &name).unwrap()`
`270`	`270`	`}`
`271`	`271`