Struct cyfs_lib::RequestorHelper

pub struct RequestorHelper;

Implementations

impl RequestorHelper

pub fn new_response(code: StatusCode) -> Response

pub fn new_ok_response<R>() -> Rwhere
    R: From<Response>,

pub fn trans_error<R>(e: BuckyError) -> Rwhere
    R: From<Response>,

pub async fn error_from_resp(resp: &mut Response) -> BuckyError

pub fn insert_device_list_header(
    http_req: &mut Request,
    device_list: &Vec<DeviceId>
)

pub fn insert_headers<T>(http_req: &mut Request, name: &str, list: &Vec<T>)where
    T: ToString,

pub fn trans_status_code(code: StatusCode) -> BuckyErrorCode

pub fn decode_optional_hex_header<R>(
    req: &R,
    name: &str
) -> BuckyResult<Option<Vec<u8>>>where
    R: HeaderOp,

pub fn decode_optional_header<T, R>(
    req: &R,
    name: impl Into<HeaderName>
) -> BuckyResult<Option<T>>where
    R: HeaderOp,
    T: FromStr,
    <T as FromStr>::Err: Display,

pub fn decode_utf8(name: &str, value: &str) -> BuckyResult<String>

pub fn decode_optional_header_with_utf8_decoding<R>(
    req: &R,
    name: impl Into<HeaderName>
) -> BuckyResult<Option<String>>where
    R: HeaderOp,

pub fn decode_header<T, R>(
    req: &R,
    name: impl Into<HeaderName>
) -> BuckyResult<T>where
    R: HeaderOp,
    T: FromStr,
    <T as FromStr>::Err: Display,

pub fn decode_header_with_utf8_decoding<R>(
    req: &R,
    name: impl Into<HeaderName>
) -> BuckyResult<String>where
    R: HeaderOp,

pub fn decode_optional_headers<T, R>(
    req: &R,
    name: impl Into<HeaderName>
) -> BuckyResult<Option<Vec<T>>>where
    R: HeaderOp,
    T: FromStr,
    <T as FromStr>::Err: Display,

pub fn decode_headers<T, R>(
    req: &R,
    name: impl Into<HeaderName>
) -> BuckyResult<Vec<T>>where
    R: HeaderOp,
    T: FromStr,
    <T as FromStr>::Err: Display,

pub fn decode_json_header<T, R>(
    req: &R,
    name: impl Into<HeaderName>
) -> BuckyResult<T>where
    R: HeaderOp,
    T: JsonCodec<T>,

pub fn decode_optional_json_header<T, R>(
    req: &R,
    name: impl Into<HeaderName>
) -> BuckyResult<Option<T>>where
    R: HeaderOp,
    T: JsonCodec<T>,

pub fn decode_optional_json_headers<T, R>(
    req: &R,
    name: impl Into<HeaderName>
) -> BuckyResult<Option<Vec<T>>>where
    R: HeaderOp,
    T: JsonCodec<T>,

pub async fn decode_raw_data_body<R>(body: &mut R) -> BuckyResult<Vec<u8>>where
    R: BodyOp,

pub async fn decode_raw_object_body<R, T>(body: &mut R) -> BuckyResult<T>where
    R: BodyOp,
    T: for<'d> RawDecode<'d>,

pub async fn decode_str_body<R, T>(body: &mut R) -> BuckyResult<T>where
    R: BodyOp,
    T: FromStr,
    <T as FromStr>::Err: Display,

pub async fn decode_json_body<R, T>(resp: &mut R) -> BuckyResult<T>where
    R: BodyOp,
    T: JsonCodec<T>,

pub async fn decode_serde_json_body<R, T>(resp: &mut R) -> BuckyResult<T>where
    R: BodyOp,
    T: for<'de> Deserialize<'de>,

pub fn decode_url_param<T>(k: Cow<'_, str>, v: Cow<'_, str>) -> BuckyResult<T>where
    T: FromStr,
    <T as FromStr>::Err: Display,

pub fn decode_url_param_list<T>(
    k: Cow<'_, str>,
    v: Cow<'_, str>
) -> BuckyResult<Vec<T>>where
    T: FromStr,
    <T as FromStr>::Err: Display,

pub fn encode_opt_header<T, R>(req: &mut R, name: &str, value: &Option<T>)where
    R: HeaderOp,
    T: ToString,

pub fn encode_opt_header_with_encoding<R>(
    req: &mut R,
    name: &str,
    value: Option<&str>
)where
    R: HeaderOp,

pub fn encode_header<T, R>(req: &mut R, name: &str, value: &T)where
    R: HeaderOp,
    T: ToString,

pub fn encode_header_with_encoding<R>(req: &mut R, name: &str, value: &str)where
    R: HeaderOp,

pub fn encode_time_header<R>(
    req: &mut R,
    name: impl Into<HeaderName>,
    bucky_time: u64
)where
    R: HeaderOp,

pub async fn request_to_service(
    service_addr: &SocketAddr,
    req: Request
) -> BuckyResult<Response>

pub fn value_from_querys<T>(name: &str, url: &Url) -> BuckyResult<Option<T>>where
    T: FromStr,
    <T as FromStr>::Err: Display,